@iternio/react-native-auto-play 0.0.1

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

@@ -0,0 +1,14 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { NitroGridTemplateConfig } from '../templates/GridTemplate';
+import type { NitroGridButton } from '../utils/NitroGrid';
+import type { NitroTemplateConfig } from './AutoPlay.nitro';
+interface GridTemplateConfig extends NitroTemplateConfig, NitroGridTemplateConfig {
+}
+export interface GridTemplate extends HybridObject<{
+    android: 'kotlin';
+    ios: 'swift';
+}> {
+    createGridTemplate(config: GridTemplateConfig): void;
+    updateGridTemplateButtons(templateId: string, buttons: Array<NitroGridButton>): void;
+}
+export {};

package/lib/specs/GridTemplate.nitro.js

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

package/lib/specs/HybridAndroidAutoTelemetry.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 HybridAndroidAutoTelemetry 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/HybridAndroidAutoTelemetry.nitro.js

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

package/lib/specs/HybridAutoPlay.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 HybridAutoPlay 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/HybridAutoPlay.nitro.js

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

package/lib/specs/HybridCarPlayDashboard.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 HybridCarPlayDashboard 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/HybridCarPlayDashboard.nitro.js

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

package/lib/specs/HybridCluster.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 HybridCluster 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/HybridCluster.nitro.js

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

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

@@ -0,0 +1,14 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { NitroGridTemplateConfig } from '../templates/GridTemplate';
+import type { NitroGridButton } from '../utils/NitroGrid';
+import type { NitroTemplateConfig } from './HybridAutoPlay.nitro';
+interface GridTemplateConfig extends NitroTemplateConfig, NitroGridTemplateConfig {
+}
+export interface HybridGridTemplate extends HybridObject<{
+    android: 'kotlin';
+    ios: 'swift';
+}> {
+    createGridTemplate(config: GridTemplateConfig): void;
+    updateGridTemplateButtons(templateId: string, buttons: Array<NitroGridButton>): void;
+}
+export {};

package/lib/specs/HybridGridTemplate.nitro.js

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

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

@@ -0,0 +1,13 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { NitroInformationTemplateConfig } from '../templates/InformationTemplate';
+import type { NitroTemplateConfig } from './HybridAutoPlay.nitro';
+interface InformationTemplateConfig extends NitroTemplateConfig, NitroInformationTemplateConfig {
+}
+export interface HybridInformationTemplate extends HybridObject<{
+    android: 'kotlin';
+    ios: 'swift';
+}> {
+    createInformationTemplate(config: InformationTemplateConfig): void;
+    updateInformationTemplateSections(templateId: string, section: NitroInformationTemplateConfig['section']): void;
+}
+export {};

package/lib/specs/HybridInformationTemplate.nitro.js

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

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

@@ -0,0 +1,13 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { NitroListTemplateConfig } from '../templates/ListTemplate';
+import type { NitroTemplateConfig } from './HybridAutoPlay.nitro';
+interface ListTemplateConfig extends NitroTemplateConfig, NitroListTemplateConfig {
+}
+export interface HybridListTemplate extends HybridObject<{
+    android: 'kotlin';
+    ios: 'swift';
+}> {
+    createListTemplate(config: ListTemplateConfig): void;
+    updateListTemplateSections(templateId: string, sections: NitroListTemplateConfig['sections']): void;
+}
+export {};

package/lib/specs/HybridListTemplate.nitro.js

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

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

@@ -0,0 +1,25 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { NavigationAlertCallbacks, NitroMapTemplateConfig, TripSelectorCallback, VisibleTravelEstimate } from '../templates/MapTemplate';
+import type { TripConfig, TripPoint, TripPreviewTextConfiguration, TripsConfig } from '../types/Trip';
+import type { NitroNavigationAlert } from '../utils/NitroAlert';
+import type { NitroManeuver } from '../utils/NitroManeuver';
+import type { NitroMapButton } from '../utils/NitroMapButton';
+import type { NitroTemplateConfig } from './HybridAutoPlay.nitro';
+interface MapTemplateConfig extends NitroTemplateConfig, NitroMapTemplateConfig {
+}
+export interface HybridMapTemplate extends HybridObject<{
+    android: 'kotlin';
+    ios: 'swift';
+}> {
+    createMapTemplate(config: MapTemplateConfig): void;
+    showNavigationAlert(templateId: string, alert: NitroNavigationAlert): NavigationAlertCallbacks;
+    showTripSelector(templateId: string, trips: Array<TripsConfig>, selectedTripId: string | undefined, textConfig: TripPreviewTextConfiguration, onTripSelected: (tripId: string, routeId: string) => void, onTripStarted: (tripId: string, routeId: string) => void, onBackPressed: () => void, mapButtons: Array<NitroMapButton>): TripSelectorCallback;
+    hideTripSelector(templateId: string): void;
+    setTemplateMapButtons(templateId: string, buttons?: Array<NitroMapButton>): void;
+    updateVisibleTravelEstimate(templateId: string, visibleTravelEstimate: VisibleTravelEstimate): void;
+    updateTravelEstimates(templateId: string, steps: Array<TripPoint>): void;
+    updateManeuvers(templateId: string, maneuvers: NitroManeuver): void;
+    startNavigation(templateId: string, trip: TripConfig): void;
+    stopNavigation(templateId: string): void;
+}
+export {};

package/lib/specs/HybridMapTemplate.nitro.js

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

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

@@ -0,0 +1,12 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { NitroMessageTemplateConfig } from '../templates/MessageTemplate';
+import type { NitroTemplateConfig } from './HybridAutoPlay.nitro';
+interface MessageTemplateConfig extends NitroTemplateConfig, NitroMessageTemplateConfig {
+}
+export interface HybridMessageTemplate extends HybridObject<{
+    android: 'kotlin';
+    ios: 'swift';
+}> {
+    createMessageTemplate(config: MessageTemplateConfig): void;
+}
+export {};

package/lib/specs/HybridMessageTemplate.nitro.js

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

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

@@ -0,0 +1,13 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { NitroSearchTemplateConfig } from '../templates/SearchTemplate';
+import type { NitroTemplateConfig } from './HybridAutoPlay.nitro';
+interface SearchTemplateConfig extends NitroTemplateConfig, NitroSearchTemplateConfig {
+}
+export interface HybridSearchTemplate extends HybridObject<{
+    android: 'kotlin';
+    ios: 'swift';
+}> {
+    createSearchTemplate(config: SearchTemplateConfig): void;
+    updateSearchResults(templateId: string, results: NitroSearchTemplateConfig['results']): void;
+}
+export {};

package/lib/specs/HybridSearchTemplate.nitro.js

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

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

@@ -0,0 +1,13 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { NitroInformationTemplateConfig } from '../templates/InformationTemplate';
+import type { NitroTemplateConfig } from './AutoPlay.nitro';
+interface InformationTemplateConfig extends NitroTemplateConfig, NitroInformationTemplateConfig {
+}
+export interface InformationTemplate extends HybridObject<{
+    android: 'kotlin';
+    ios: 'swift';
+}> {
+    createInformationTemplate(config: InformationTemplateConfig): void;
+    updateInformationTemplateSections(templateId: string, section: NitroInformationTemplateConfig['section']): void;
+}
+export {};

package/lib/specs/InformationTemplate.nitro.js

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

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

@@ -0,0 +1,13 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { NitroListTemplateConfig } from '../templates/ListTemplate';
+import type { NitroTemplateConfig } from './AutoPlay.nitro';
+interface ListTemplateConfig extends NitroTemplateConfig, NitroListTemplateConfig {
+}
+export interface ListTemplate extends HybridObject<{
+    android: 'kotlin';
+    ios: 'swift';
+}> {
+    createListTemplate(config: ListTemplateConfig): void;
+    updateListTemplateSections(templateId: string, sections: NitroListTemplateConfig['sections']): void;
+}
+export {};

package/lib/specs/ListTemplate.nitro.js

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

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

@@ -0,0 +1,25 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { NavigationAlertCallbacks, NitroMapTemplateConfig, TripSelectorCallback, VisibleTravelEstimate } from '../templates/MapTemplate';
+import type { TripConfig, TripPoint, TripPreviewTextConfiguration, TripsConfig } from '../types/Trip';
+import type { NitroNavigationAlert } from '../utils/NitroAlert';
+import type { NitroManeuver } from '../utils/NitroManeuver';
+import type { NitroMapButton } from '../utils/NitroMapButton';
+import type { NitroTemplateConfig } from './AutoPlay.nitro';
+interface MapTemplateConfig extends NitroTemplateConfig, NitroMapTemplateConfig {
+}
+export interface MapTemplate extends HybridObject<{
+    android: 'kotlin';
+    ios: 'swift';
+}> {
+    createMapTemplate(config: MapTemplateConfig): void;
+    showNavigationAlert(templateId: string, alert: NitroNavigationAlert): NavigationAlertCallbacks;
+    showTripSelector(templateId: string, trips: Array<TripsConfig>, selectedTripId: string | undefined, textConfig: TripPreviewTextConfiguration, onTripSelected: (tripId: string, routeId: string) => void, onTripStarted: (tripId: string, routeId: string) => void, onBackPressed: () => void, mapButtons: Array<NitroMapButton>): TripSelectorCallback;
+    hideTripSelector(templateId: string): void;
+    setTemplateMapButtons(templateId: string, buttons?: Array<NitroMapButton>): void;
+    updateVisibleTravelEstimate(templateId: string, visibleTravelEstimate: VisibleTravelEstimate): void;
+    updateTravelEstimates(templateId: string, steps: Array<TripPoint>): void;
+    updateManeuvers(templateId: string, maneuvers: NitroManeuver): void;
+    startNavigation(templateId: string, trip: TripConfig): void;
+    stopNavigation(templateId: string): void;
+}
+export {};

package/lib/specs/MapTemplate.nitro.js

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

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

@@ -0,0 +1,12 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { NitroMessageTemplateConfig } from '../templates/MessageTemplate';
+import type { NitroTemplateConfig } from './AutoPlay.nitro';
+interface MessageTemplateConfig extends NitroTemplateConfig, NitroMessageTemplateConfig {
+}
+export interface MessageTemplate extends HybridObject<{
+    android: 'kotlin';
+    ios: 'swift';
+}> {
+    createMessageTemplate(config: MessageTemplateConfig): void;
+}
+export {};

package/lib/specs/MessageTemplate.nitro.js

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

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

@@ -0,0 +1,13 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { NitroSearchTemplateConfig } from '../templates/SearchTemplate';
+import type { NitroTemplateConfig } from './AutoPlay.nitro';
+interface SearchTemplateConfig extends NitroTemplateConfig, NitroSearchTemplateConfig {
+}
+export interface SearchTemplate extends HybridObject<{
+    android: 'kotlin';
+    ios: 'swift';
+}> {
+    createSearchTemplate(config: SearchTemplateConfig): void;
+    updateSearchResults(templateId: string, results: NitroSearchTemplateConfig['results']): void;
+}
+export {};

package/lib/specs/SearchTemplate.nitro.js

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

package/lib/templates/GridTemplate.d.ts

@@ -0,0 +1,28 @@
+import type { AutoText } from '../types/Text';
+import { type NitroAction } from '../utils/NitroAction';
+import { type GridButton, type NitroGridButton } from '../utils/NitroGrid';
+import type { BaseMapTemplateConfig } from './MapTemplate';
+import { type HeaderActions, type NitroBaseMapTemplateConfig, Template, type TemplateConfig } from './Template';
+export interface NitroGridTemplateConfig extends TemplateConfig {
+    headerActions?: Array<NitroAction>;
+    title: AutoText;
+    buttons: Array<NitroGridButton>;
+    mapConfig?: NitroBaseMapTemplateConfig;
+}
+export type GridTemplateConfig = Omit<NitroGridTemplateConfig, 'headerActions' | 'buttons' | 'mapConfig'> & {
+    /**
+     * action buttons, usually at the the top right on Android and a top bar on iOS
+     */
+    headerActions?: HeaderActions<GridTemplate>;
+    buttons: Array<GridButton<GridTemplate>>;
+    /**
+     * If mapConfig is defined, it will use a MapWithContentTemplate with the current template. This results in a GridTemplate with a map in background. No actions need to be specified, can be empty object.
+     * @namespace Android
+     */
+    mapConfig?: BaseMapTemplateConfig<GridTemplate>;
+};
+export declare class GridTemplate extends Template<GridTemplateConfig, HeaderActions<GridTemplate>> {
+    private template;
+    constructor(config: GridTemplateConfig);
+    updateGrid(buttons: Array<GridButton<GridTemplate>>): void;
+}

package/lib/templates/GridTemplate.js

@@ -0,0 +1,29 @@
+import { NitroModules } from 'react-native-nitro-modules';
+import { NitroActionUtil } from '../utils/NitroAction';
+import { NitroGridUtil } from '../utils/NitroGrid';
+import { NitroMapButton } from '../utils/NitroMapButton';
+import { Template, } from './Template';
+const HybridGridTemplate = NitroModules.createHybridObject('GridTemplate');
+export class GridTemplate extends Template {
+    template = this;
+    constructor(config) {
+        super(config);
+        const { headerActions, buttons, mapConfig, ...rest } = config;
+        const nitroConfig = {
+            ...rest,
+            id: this.id,
+            headerActions: NitroActionUtil.convert(this.template, headerActions),
+            buttons: NitroGridUtil.convert(this.template, buttons),
+            mapConfig: mapConfig
+                ? {
+                    mapButtons: NitroMapButton.convert(this.template, mapConfig.mapButtons),
+                    headerActions: NitroActionUtil.convert(this.template, mapConfig.headerActions),
+                }
+                : undefined,
+        };
+        HybridGridTemplate.createGridTemplate(nitroConfig);
+    }
+    updateGrid(buttons) {
+        HybridGridTemplate.updateGridTemplateButtons(this.id, NitroGridUtil.convert(this.template, buttons));
+    }
+}

package/lib/templates/InformationTemplate.d.ts

@@ -0,0 +1,52 @@
+import type { CustomActionButtonAndroid, TextButton } from '../types/Button';
+import type { AutoText } from '../types/Text';
+import { type NitroAction } from '../utils/NitroAction';
+import { type NitroSection } from '../utils/NitroSection';
+import type { TextRow } from './ListTemplate';
+import type { BaseMapTemplateConfig } from './MapTemplate';
+import { type HeaderActions, type NitroBaseMapTemplateConfig, Template, type TemplateConfig } from './Template';
+export interface NitroInformationTemplateConfig extends TemplateConfig {
+    headerActions?: Array<NitroAction>;
+    title: AutoText;
+    section: NitroSection;
+    actions?: Array<NitroAction>;
+    mapConfig?: NitroBaseMapTemplateConfig;
+}
+export type InformationItems = [TextRow] | [TextRow, TextRow] | [TextRow, TextRow, TextRow] | [TextRow, TextRow, TextRow, TextRow];
+export type InformationTemplateConfig = Omit<NitroInformationTemplateConfig, 'headerActions' | 'section' | 'mapConfig' | 'actions'> & {
+    /**
+     * action buttons, usually at the the top right on Android and a top bar on iOS
+     */
+    headerActions?: HeaderActions<InformationTemplate>;
+    /**
+     * @namespace Android this is a PaneTemplate with a list of rows. Each row can have a title with up to 2 rows and a detailedText with up to 4 rows, either as a single string that is automatically wrapped or a string with line breaks. However if the text is too long it might be broken into multiple rows and then truncated, if more than 4 rows are required due to wrapping.
+     * @namespace iOS this is an InformationTemplate, ⚠️ the row image is NOT supported
+     */
+    items?: InformationItems;
+    /**
+     * If mapConfig is defined, it will use a MapWithContentTemplate with the current template. This results in a PaneTemplate with a map in background. No actions need to be specified, can be empty object.
+     * @namespace Android
+     */
+    mapConfig?: BaseMapTemplateConfig<InformationTemplate>;
+    /**
+     * @namespace Android up to 2 buttons of type TextButton, TextAndImageButton or ImageButton
+     * @namespace iOS - up to 3 buttons of type TextButton
+     */
+    actions?: {
+        android?: [CustomActionButtonAndroid<InformationTemplate>] | [
+            CustomActionButtonAndroid<InformationTemplate>,
+            CustomActionButtonAndroid<InformationTemplate>
+        ];
+        ios?: [
+            TextButton<InformationTemplate>,
+            TextButton<InformationTemplate>,
+            TextButton<InformationTemplate>
+        ] | [TextButton<InformationTemplate>, TextButton<InformationTemplate>] | [TextButton<InformationTemplate>];
+    };
+};
+export declare class InformationTemplate extends Template<InformationTemplateConfig, HeaderActions<InformationTemplate>> {
+    private template;
+    constructor(config: InformationTemplateConfig);
+    updateItems(items?: InformationItems): void;
+    private getSection;
+}

package/lib/templates/InformationTemplate.js

@@ -0,0 +1,45 @@
+import { Platform } from 'react-native';
+import { NitroModules } from 'react-native-nitro-modules';
+import { NitroActionUtil } from '../utils/NitroAction';
+import { NitroMapButton } from '../utils/NitroMapButton';
+import { NitroSectionUtil } from '../utils/NitroSection';
+import { Template, } from './Template';
+const HybridInformationTemplate = NitroModules.createHybridObject('InformationTemplate');
+export class InformationTemplate extends Template {
+    template = this;
+    constructor(config) {
+        super(config);
+        const { headerActions, mapConfig, items, actions, ...rest } = config;
+        const platformActions = Platform.OS === 'android'
+            ? NitroActionUtil.convert(this.template, actions?.android)
+            : NitroActionUtil.convert(this.template, actions?.ios);
+        const section = this.getSection(items);
+        const nitroConfig = {
+            ...rest,
+            id: this.id,
+            headerActions: NitroActionUtil.convert(this.template, headerActions),
+            actions: platformActions,
+            section: NitroSectionUtil.convert(this.template, section)?.at(0) ?? {
+                items: [],
+                type: 'default',
+            },
+            mapConfig: mapConfig
+                ? {
+                    mapButtons: NitroMapButton.convert(this.template, mapConfig.mapButtons),
+                    headerActions: NitroActionUtil.convert(this.template, mapConfig.headerActions),
+                }
+                : undefined,
+        };
+        HybridInformationTemplate.createInformationTemplate(nitroConfig);
+    }
+    updateItems(items) {
+        const section = this.getSection(items);
+        HybridInformationTemplate.updateInformationTemplateSections(this.id, NitroSectionUtil.convert(this.template, section)?.at(0) ?? { items: [], type: 'default' });
+    }
+    getSection(items) {
+        return {
+            type: 'default',
+            items: items ?? [],
+        };
+    }
+}

package/lib/templates/ListTemplate.d.ts

@@ -0,0 +1,77 @@
+import type { AutoImage } from '../types/Image';
+import type { AutoText } from '../types/Text';
+import { type NitroAction } from '../utils/NitroAction';
+import { type NitroSection } from '../utils/NitroSection';
+import type { BaseMapTemplateConfig } from './MapTemplate';
+import { type HeaderActions, type NitroBaseMapTemplateConfig, Template, type TemplateConfig } from './Template';
+type BaseRow = {
+    title: AutoText;
+    enabled?: boolean;
+    image?: AutoImage;
+};
+export type DefaultRow<T> = BaseRow & {
+    type: 'default';
+    /**
+     * adds a chevron at the end of the row
+     */
+    browsable?: boolean;
+    onPress: (template: T) => void;
+    detailedText?: AutoText;
+};
+export type ToggleRow<T> = BaseRow & {
+    type: 'toggle';
+    checked: boolean;
+    onPress: (template: T, checked: boolean) => void;
+};
+export type RadioRow<T> = BaseRow & {
+    type: 'radio';
+    onPress: (template: T) => void;
+    selected?: boolean;
+};
+export type TextRow = BaseRow & {
+    type: 'text';
+    detailedText?: AutoText;
+};
+export type MultiSection<T> = {
+    type: 'default';
+    title: string;
+    items: Array<DefaultRow<T> | ToggleRow<T> | TextRow>;
+} | {
+    type: 'radio';
+    title: string;
+    items: Array<RadioRow<T>>;
+};
+export type SingleSection<T> = {
+    [K in MultiSection<T> as K['type']]: Omit<K, 'title' | 'detailedText'>;
+}[MultiSection<T>['type']];
+export type Section<T> = Array<MultiSection<T>> | SingleSection<T>;
+export interface NitroListTemplateConfig extends TemplateConfig {
+    headerActions?: Array<NitroAction>;
+    title: AutoText;
+    sections?: Array<NitroSection>;
+    mapConfig?: NitroBaseMapTemplateConfig;
+}
+export type ListTemplateConfig = Omit<NitroListTemplateConfig, 'headerActions' | 'sections' | 'mapConfig'> & {
+    /**
+     * action buttons, usually at the the top right on Android and a top bar on iOS
+     */
+    headerActions?: HeaderActions<ListTemplate>;
+    /**
+     * a container that groups your list items into sections.
+     * must have a single selected item in case it is a radio list.
+     * in case it does not the first item will be selected.
+     * in case it has multiple only the first selected one will be shown as selected.
+     */
+    sections?: Section<ListTemplate>;
+    /**
+     * If mapConfig is defined, it will use a MapWithContentTemplate with the current template. This results in a ListTemplate with a map in background. No actions need to be specified, can be empty object.
+     * @namespace Android
+     */
+    mapConfig?: BaseMapTemplateConfig<ListTemplate>;
+};
+export declare class ListTemplate extends Template<ListTemplateConfig, HeaderActions<ListTemplate>> {
+    private template;
+    constructor(config: ListTemplateConfig);
+    updateSections(sections?: Section<ListTemplate>): void;
+}
+export {};

package/lib/templates/ListTemplate.js

@@ -0,0 +1,29 @@
+import { NitroModules } from 'react-native-nitro-modules';
+import { NitroActionUtil } from '../utils/NitroAction';
+import { NitroMapButton } from '../utils/NitroMapButton';
+import { NitroSectionUtil } from '../utils/NitroSection';
+import { Template, } from './Template';
+const HybridListTemplate = NitroModules.createHybridObject('ListTemplate');
+export class ListTemplate extends Template {
+    template = this;
+    constructor(config) {
+        super(config);
+        const { headerActions, mapConfig, sections, ...rest } = config;
+        const nitroConfig = {
+            ...rest,
+            id: this.id,
+            headerActions: NitroActionUtil.convert(this.template, headerActions),
+            sections: NitroSectionUtil.convert(this.template, sections),
+            mapConfig: mapConfig
+                ? {
+                    mapButtons: NitroMapButton.convert(this.template, mapConfig.mapButtons),
+                    headerActions: NitroActionUtil.convert(this.template, mapConfig.headerActions),
+                }
+                : undefined,
+        };
+        HybridListTemplate.createListTemplate(nitroConfig);
+    }
+    updateSections(sections) {
+        HybridListTemplate.updateListTemplateSections(this.id, NitroSectionUtil.convert(this.template, sections));
+    }
+}