react-native-tvos 0.87.1-0 → 0.88.0-0rc2

package/types_generated/Libraries/Lists/FlatList.d.ts

@@ -0,0 +1,316 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @generated SignedSource<<8fe72ba1f479e072d8015ccb7e010ea7>>
+ *
+ * This file was translated from Flow by scripts/js-api/build-types/index.js.
+ * Original file: packages/react-native/Libraries/Lists/FlatList.js
+ */
+
+import type { ScrollViewInstance } from "../Components/ScrollView/ScrollView";
+import type { ViewStyleProp } from "../StyleSheet/StyleSheet";
+import type { ListRenderItem, VirtualizedListProps } from "@react-native-tvos/virtualized-lists";
+import { type ScrollResponderType } from "../Components/ScrollView/ScrollView";
+import * as React from "react";
+type RequiredFlatListProps<ItemT> = {
+  /**
+   * An array (or array-like list) of items to render. Other data types can be
+   * used by targeting VirtualizedList directly.
+   */
+  data: Readonly<ArrayLike<ItemT>> | undefined;
+};
+type OptionalFlatListProps<ItemT> = {
+  /**
+   * Takes an item from `data` and renders it into the list. Example usage:
+   *
+   *     <FlatList
+   *       ItemSeparatorComponent={Platform.OS !== 'android' && ({highlighted}) => (
+   *         <View style={[style.separator, highlighted && {marginLeft: 0}]} />
+   *       )}
+   *       data={[{title: 'Title Text', key: 'item1'}]}
+   *       renderItem={({item, separators}) => (
+   *         <TouchableHighlight
+   *           onPress={() => this._onPress(item)}
+   *           onShowUnderlay={separators.highlight}
+   *           onHideUnderlay={separators.unhighlight}>
+   *           <View style={{backgroundColor: 'white'}}>
+   *             <Text>{item.title}</Text>
+   *           </View>
+   *         </TouchableHighlight>
+   *       )}
+   *     />
+   *
+   * Provides additional metadata like `index` if you need it, as well as a more generic
+   * `separators.updateProps` function which let's you set whatever props you want to change the
+   * rendering of either the leading separator or trailing separator in case the more common
+   * `highlight` and `unhighlight` (which set the `highlighted: boolean` prop) are insufficient for
+   * your use-case.
+   */
+  renderItem?: ListRenderItem<ItemT> | undefined;
+  /**
+   * Optional custom style for multi-item rows generated when numColumns > 1.
+   */
+  columnWrapperStyle?: ViewStyleProp | undefined;
+  /**
+   * A marker property for telling the list to re-render (since it implements `PureComponent`). If
+   * any of your `renderItem`, Header, Footer, etc. functions depend on anything outside of the
+   * `data` prop, stick it here and treat it immutably.
+   */
+  extraData?: any | undefined;
+  /**
+   * `getItemLayout` is an optional optimizations that let us skip measurement of dynamic content if
+   * you know the height of items a priori. `getItemLayout` is the most efficient, and is easy to
+   * use if you have fixed height items, for example:
+   *
+   *     getItemLayout={(data, index) => (
+   *       {length: ITEM_HEIGHT, offset: ITEM_HEIGHT * index, index}
+   *     )}
+   *
+   * Adding `getItemLayout` can be a great performance boost for lists of several hundred items.
+   * Remember to include separator length (height or width) in your offset calculation if you
+   * specify `ItemSeparatorComponent`.
+   */
+  getItemLayout?: ((data: Readonly<ArrayLike<ItemT>> | undefined, index: number) => {
+    length: number;
+    offset: number;
+    index: number;
+  }) | undefined;
+  /**
+   * If true, renders items next to each other horizontally instead of stacked vertically.
+   */
+  horizontal?: boolean | undefined;
+  /**
+   * How many items to render in the initial batch. This should be enough to fill the screen but not
+   * much more. Note these items will never be unmounted as part of the windowed rendering in order
+   * to improve perceived performance of scroll-to-top actions.
+   */
+  initialNumToRender?: number | undefined;
+  /**
+   * Instead of starting at the top with the first item, start at `initialScrollIndex`. This
+   * disables the "scroll to top" optimization that keeps the first `initialNumToRender` items
+   * always rendered and immediately renders the items starting at this initial index. Requires
+   * `getItemLayout` to be implemented.
+   */
+  initialScrollIndex?: number | undefined;
+  /**
+   * Reverses the direction of scroll. Uses scale transforms of -1.
+   */
+  inverted?: boolean | undefined;
+  /**
+   * Used to extract a unique key for a given item at the specified index. Key is used for caching
+   * and as the react key to track item re-ordering. The default extractor checks `item.key`, then
+   * falls back to using the index, like React does.
+   */
+  keyExtractor?: ((item: ItemT, index: number) => string) | undefined;
+  /**
+   * Multiple columns can only be rendered with `horizontal={false}` and will zig-zag like a
+   * `flexWrap` layout. Items should all be the same height - masonry layouts are not supported.
+   *
+   * The default value is 1.
+   */
+  numColumns?: number | undefined;
+  /**
+   * Note: may have bugs (missing content) in some circumstances - use at your own risk.
+   *
+   * This may improve scroll performance for large lists.
+   *
+   * The default value is true for Android.
+   */
+  removeClippedSubviews?: boolean | undefined;
+  /**
+   * See `ScrollView` for flow type and further documentation.
+   */
+  fadingEdgeLength?: (number | undefined) | {
+    start: number;
+    end: number;
+  } | undefined;
+  /**
+   * Enable an optimization to memoize the item renderer to prevent unnecessary rerenders.
+   */
+  strictMode?: boolean | undefined;
+};
+type FlatListBaseProps<ItemT> = Omit<RequiredFlatListProps<ItemT>, keyof OptionalFlatListProps<ItemT> | keyof {}> & Omit<OptionalFlatListProps<ItemT>, keyof {}> & {};
+export interface FlatListProps<ItemT> extends Readonly<Omit<Omit<VirtualizedListProps, "data" | "getItem" | "getItemCount" | "getItemLayout" | "renderItem" | "keyExtractor">, keyof FlatListBaseProps<ItemT> | keyof {}> & Omit<FlatListBaseProps<ItemT>, keyof {}>> {}
+/**
+ * A performant interface for rendering simple, flat lists, supporting the most handy features:
+ *
+ *  - Fully cross-platform.
+ *  - Optional horizontal mode.
+ *  - Configurable viewability callbacks.
+ *  - Header support.
+ *  - Footer support.
+ *  - Separator support.
+ *  - Pull to Refresh.
+ *  - Scroll loading.
+ *  - ScrollToIndex support.
+ *
+ * If you need section support, use [`<SectionList>`](docs/sectionlist.html).
+ *
+ * Minimal Example:
+ *
+ *     <FlatList
+ *       data={[{key: 'a'}, {key: 'b'}]}
+ *       renderItem={({item}) => <Text>{item.key}</Text>}
+ *     />
+ *
+ * More complex, multi-select example demonstrating `PureComponent` usage for perf optimization and avoiding bugs.
+ *
+ * - By binding the `onPressItem` handler, the props will remain `===` and `PureComponent` will
+ *   prevent wasteful re-renders unless the actual `id`, `selected`, or `title` props change, even
+ *   if the components rendered in `MyListItem` did not have such optimizations.
+ * - By passing `extraData={this.state}` to `FlatList` we make sure `FlatList` itself will re-render
+ *   when the `state.selected` changes. Without setting this prop, `FlatList` would not know it
+ *   needs to re-render any items because it is also a `PureComponent` and the prop comparison will
+ *   not show any changes.
+ * - `keyExtractor` tells the list to use the `id`s for the react keys instead of the default `key` property.
+ *
+ *
+ *     class MyListItem extends React.PureComponent {
+ *       _onPress = () => {
+ *         this.props.onPressItem(this.props.id);
+ *       };
+ *
+ *       render() {
+ *         const textColor = this.props.selected ? "red" : "black";
+ *         return (
+ *           <TouchableOpacity onPress={this._onPress}>
+ *             <View>
+ *               <Text style={{ color: textColor }}>
+ *                 {this.props.title}
+ *               </Text>
+ *             </View>
+ *           </TouchableOpacity>
+ *         );
+ *       }
+ *     }
+ *
+ *     class MultiSelectList extends React.PureComponent {
+ *       state = {selected: (new Map(): Map<string, boolean>)};
+ *
+ *       _keyExtractor = (item, index) => item.id;
+ *
+ *       _onPressItem = (id: string) => {
+ *         // updater functions are preferred for transactional updates
+ *         this.setState((state) => {
+ *           // copy the map rather than modifying state.
+ *           const selected = new Map(state.selected);
+ *           selected.set(id, !selected.get(id)); // toggle
+ *           return {selected};
+ *         });
+ *       };
+ *
+ *       _renderItem = ({item}) => (
+ *         <MyListItem
+ *           id={item.id}
+ *           onPressItem={this._onPressItem}
+ *           selected={!!this.state.selected.get(item.id)}
+ *           title={item.title}
+ *         />
+ *       );
+ *
+ *       render() {
+ *         return (
+ *           <FlatList
+ *             data={this.props.data}
+ *             extraData={this.state}
+ *             keyExtractor={this._keyExtractor}
+ *             renderItem={this._renderItem}
+ *           />
+ *         );
+ *       }
+ *     }
+ *
+ * This is a convenience wrapper around [`<VirtualizedList>`](docs/virtualizedlist.html),
+ * and thus inherits its props (as well as those of `ScrollView`) that aren't explicitly listed
+ * here, along with the following caveats:
+ *
+ * - Internal state is not preserved when content scrolls out of the render window. Make sure all
+ *   your data is captured in the item data or external stores like Flux, Redux, or Relay.
+ * - This is a `PureComponent` which means that it will not re-render if `props` remain shallow-
+ *   equal. Make sure that everything your `renderItem` function depends on is passed as a prop
+ *   (e.g. `extraData`) that is not `===` after updates, otherwise your UI may not update on
+ *   changes. This includes the `data` prop and parent component state.
+ * - In order to constrain memory and enable smooth scrolling, content is rendered asynchronously
+ *   offscreen. This means it's possible to scroll faster than the fill rate ands momentarily see
+ *   blank content. This is a tradeoff that can be adjusted to suit the needs of each application,
+ *   and we are working on improving it behind the scenes.
+ * - By default, the list looks for a `key` prop on each item and uses that for the React key.
+ *   Alternatively, you can provide a custom `keyExtractor` prop.
+ *
+ * Also inherits [ScrollView Props](docs/scrollview.html#props), unless it is nested in another FlatList of same orientation.
+ */
+declare class FlatList<ItemT = any> extends React.PureComponent<FlatListProps<ItemT>> {
+  /**
+   * Scrolls to the end of the content. May be janky without `getItemLayout` prop.
+   */
+  scrollToEnd(params?: null | undefined | {
+    animated?: boolean | undefined;
+  }): void;
+  /**
+   * Scrolls to the item at the specified index such that it is positioned in the viewable area
+   * such that `viewPosition` 0 places it at the top, 1 at the bottom, and 0.5 centered in the
+   * middle. `viewOffset` is a fixed number of pixels to offset the final target position.
+   *
+   * Note: cannot scroll to locations outside the render window without specifying the
+   * `getItemLayout` prop.
+   */
+  scrollToIndex(params: {
+    animated?: boolean | undefined;
+    index: number;
+    viewOffset?: number | undefined;
+    viewPosition?: number | undefined;
+  }): void;
+  /**
+   * Requires linear scan through data - use `scrollToIndex` instead if possible.
+   *
+   * Note: cannot scroll to locations outside the render window without specifying the
+   * `getItemLayout` prop.
+   */
+  scrollToItem(params: {
+    animated?: boolean | undefined;
+    item: ItemT;
+    viewOffset?: number | undefined;
+    viewPosition?: number | undefined;
+  }): void;
+  /**
+   * Scroll to a specific content pixel offset in the list.
+   *
+   * Check out [scrollToOffset](docs/virtualizedlist.html#scrolltooffset) of VirtualizedList
+   */
+  scrollToOffset(params: {
+    animated?: boolean | undefined;
+    offset: number;
+  }): void;
+  /**
+   * Tells the list an interaction has occurred, which should trigger viewability calculations, e.g.
+   * if `waitForInteractions` is true and the user has not scrolled. This is typically called by
+   * taps on items or by navigation actions.
+   */
+  recordInteraction(): void;
+  /**
+   * Displays the scroll indicators momentarily.
+   *
+   * @platform ios
+   */
+  flashScrollIndicators(): void;
+  /**
+   * Provides a handle to the underlying scroll responder.
+   */
+  getScrollResponder(): null | undefined | ScrollResponderType;
+  /**
+   * Provides a reference to the underlying host component
+   */
+  getNativeScrollRef(): null | undefined | ScrollViewInstance;
+  getScrollableNode(): any;
+  setNativeProps(props: {
+    [$$Key$$: string]: unknown;
+  }): void;
+  constructor(props: FlatListProps<ItemT>);
+  componentDidUpdate(prevProps: FlatListProps<ItemT>): void;
+  render(): React.ReactNode;
+}
+export type FlatListInstance = FlatList;
+export default FlatList;

package/types_generated/Libraries/Lists/SectionList.d.ts

@@ -0,0 +1,175 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @generated SignedSource<<1a7b2a017fe8c9e5311fe69fca7626b7>>
+ *
+ * This file was translated from Flow by scripts/js-api/build-types/index.js.
+ * Original file: packages/react-native/Libraries/Lists/SectionList.js
+ */
+
+import type { ScrollResponderType } from "../Components/ScrollView/ScrollView";
+import type { ListRenderItemInfo, ScrollToLocationParamsType, SectionBase as _SectionBase, SectionData, VirtualizedSectionListProps } from "@react-native-tvos/virtualized-lists";
+import * as React from "react";
+type DefaultSectionT = {
+  [key: string]: any;
+};
+export type SectionBase<SectionItemT, SectionT = DefaultSectionT> = _SectionBase<SectionItemT, SectionT>;
+export type { SectionData as SectionListData, ScrollToLocationParamsType as SectionListScrollParams };
+type RequiredSectionListProps<ItemT, SectionT = DefaultSectionT> = {
+  /**
+   * The actual data to render, akin to the `data` prop in [`<FlatList>`](https://reactnative.dev/docs/flatlist).
+   *
+   * General shape:
+   *
+   *     sections: $ReadOnlyArray<{
+   *       data: $ReadOnlyArray<SectionItem>,
+   *       renderItem?: ({item: SectionItem, ...}) => ?React.MixedElement,
+   *       ItemSeparatorComponent?: ?ReactClass<{highlighted: boolean, ...}>,
+   *     }>
+   */
+  sections: ReadonlyArray<SectionData<ItemT, SectionT>>;
+};
+export type SectionListRenderItemInfo<ItemT, SectionT = DefaultSectionT> = Omit<ListRenderItemInfo<ItemT>, "section"> & {
+  section: SectionData<ItemT, SectionT>;
+};
+export type SectionListRenderItem<ItemT, SectionT = DefaultSectionT> = (info: SectionListRenderItemInfo<ItemT, SectionT>) => React.ReactNode | null;
+type OptionalSectionListProps<ItemT, SectionT = DefaultSectionT> = {
+  /**
+   * Default renderer for every item in every section. Can be over-ridden on a per-section basis.
+   */
+  renderItem?: SectionListRenderItem<ItemT, SectionT> | undefined;
+  /**
+   * A marker property for telling the list to re-render (since it implements `PureComponent`). If
+   * any of your `renderItem`, Header, Footer, etc. functions depend on anything outside of the
+   * `data` prop, stick it here and treat it immutably.
+   */
+  extraData?: any | undefined;
+  /**
+   * How many items to render in the initial batch. This should be enough to fill the screen but not
+   * much more. Note these items will never be unmounted as part of the windowed rendering in order
+   * to improve perceived performance of scroll-to-top actions.
+   */
+  initialNumToRender?: number | undefined;
+  /**
+   * Reverses the direction of scroll. Uses scale transforms of -1.
+   */
+  inverted?: boolean | undefined;
+  /**
+   * Used to extract a unique key for a given item at the specified index. Key is used for caching
+   * and as the react key to track item re-ordering. The default extractor checks item.key, then
+   * falls back to using the index, like react does. Note that this sets keys for each item, but
+   * each overall section still needs its own key.
+   */
+  keyExtractor?: ((item: ItemT, index: number) => string) | undefined;
+  /**
+   * Called once when the scroll position gets within `onEndReachedThreshold` of the rendered
+   * content.
+   */
+  onEndReached?: ((info: {
+    distanceFromEnd: number;
+  }) => void) | undefined;
+  /**
+   * Note: may have bugs (missing content) in some circumstances - use at your own risk.
+   *
+   * This may improve scroll performance for large lists.
+   */
+  removeClippedSubviews?: boolean | undefined;
+};
+export interface SectionListProps<ItemT, SectionT = DefaultSectionT> extends Readonly<Omit<Omit<VirtualizedSectionListProps<ItemT, SectionT>, "getItem" | "getItemCount" | "renderItem" | "keyExtractor">, keyof RequiredSectionListProps<ItemT, SectionT> | keyof OptionalSectionListProps<ItemT, SectionT> | keyof {}> & Omit<RequiredSectionListProps<ItemT, SectionT>, keyof OptionalSectionListProps<ItemT, SectionT> | keyof {}> & Omit<OptionalSectionListProps<ItemT, SectionT>, keyof {}>> {}
+/**
+ * A performant interface for rendering sectioned lists, supporting the most handy features:
+ *
+ *  - Fully cross-platform.
+ *  - Configurable viewability callbacks.
+ *  - List header support.
+ *  - List footer support.
+ *  - Item separator support.
+ *  - Section header support.
+ *  - Section separator support.
+ *  - Heterogeneous data and item rendering support.
+ *  - Pull to Refresh.
+ *  - Scroll loading.
+ *
+ * If you don't need section support and want a simpler interface, use
+ * [`<FlatList>`](https://reactnative.dev/docs/flatlist).
+ *
+ * Simple Examples:
+ *
+ *     <SectionList
+ *       renderItem={({item}) => <ListItem title={item} />}
+ *       renderSectionHeader={({section}) => <Header title={section.title} />}
+ *       sections={[ // homogeneous rendering between sections
+ *         {data: [...], title: ...},
+ *         {data: [...], title: ...},
+ *         {data: [...], title: ...},
+ *       ]}
+ *     />
+ *
+ *     <SectionList
+ *       sections={[ // heterogeneous rendering between sections
+ *         {data: [...], renderItem: ...},
+ *         {data: [...], renderItem: ...},
+ *         {data: [...], renderItem: ...},
+ *       ]}
+ *     />
+ *
+ * This is a convenience wrapper around [`<VirtualizedList>`](docs/virtualizedlist),
+ * and thus inherits its props (as well as those of `ScrollView`) that aren't explicitly listed
+ * here, along with the following caveats:
+ *
+ * - Internal state is not preserved when content scrolls out of the render window. Make sure all
+ *   your data is captured in the item data or external stores like Flux, Redux, or Relay.
+ * - This is a `PureComponent` which means that it will not re-render if `props` remain shallow-
+ *   equal. Make sure that everything your `renderItem` function depends on is passed as a prop
+ *   (e.g. `extraData`) that is not `===` after updates, otherwise your UI may not update on
+ *   changes. This includes the `data` prop and parent component state.
+ * - In order to constrain memory and enable smooth scrolling, content is rendered asynchronously
+ *   offscreen. This means it's possible to scroll faster than the fill rate and momentarily see
+ *   blank content. This is a tradeoff that can be adjusted to suit the needs of each application,
+ *   and we are working on improving it behind the scenes.
+ * - By default, the list looks for a `key` prop on each item and uses that for the React key.
+ *   Alternatively, you can provide a custom `keyExtractor` prop.
+ *
+ * @see https://reactnative.dev/docs/sectionlist
+ */
+declare class SectionList<ItemT = any, SectionT = DefaultSectionT> extends React.PureComponent<SectionListProps<ItemT, SectionT>> {
+  props: SectionListProps<ItemT, SectionT>;
+  /**
+   * Scrolls to the item at the specified `sectionIndex` and `itemIndex` (within the section)
+   * positioned in the viewable area such that `viewPosition` 0 places it at the top (and may be
+   * covered by a sticky header), 1 at the bottom, and 0.5 centered in the middle. `viewOffset` is a
+   * fixed number of pixels to offset the final target position, e.g. to compensate for sticky
+   * headers.
+   *
+   * Note: cannot scroll to locations outside the render window without specifying the
+   * `getItemLayout` prop.
+   */
+  scrollToLocation(params: ScrollToLocationParamsType): void;
+  /**
+   * Tells the list an interaction has occurred, which should trigger viewability calculations, e.g.
+   * if `waitForInteractions` is true and the user has not scrolled. This is typically called by
+   * taps on items or by navigation actions.
+   */
+  recordInteraction(): void;
+  /**
+   * Displays the scroll indicators momentarily.
+   *
+   * @platform ios
+   */
+  flashScrollIndicators(): void;
+  /**
+   * Provides a handle to the underlying scroll responder.
+   */
+  getScrollResponder(): null | undefined | ScrollResponderType;
+  /**
+   * Provides a handle to the underlying scroll node.
+   */
+  getScrollableNode(): any;
+  setNativeProps(props: Object): void;
+  render(): React.ReactNode;
+}
+export default SectionList;
+export type SectionListInstance = SectionList;

package/types_generated/Libraries/Lists/VirtualizedList.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @generated SignedSource<<390a123f3f1b4ea6d9dfd0638dae51d8>>
+ *
+ * This file was translated from Flow by scripts/js-api/build-types/index.js.
+ * Original file: packages/react-native/Libraries/Lists/VirtualizedList.js
+ */
+
+import VirtualizedLists from "@react-native-tvos/virtualized-lists";
+import * as React from "react";
+type VirtualizedListType = typeof VirtualizedLists.VirtualizedList;
+declare const VirtualizedListComponent: VirtualizedListType;
+export type VirtualizedListInstance = React.ComponentRef<VirtualizedListType>;
+export type { ListRenderItemInfo, ListRenderItem, ListViewToken, Separators, VirtualizedListProps } from "@react-native-tvos/virtualized-lists";
+declare const $$VirtualizedList: typeof VirtualizedListComponent;
+declare type $$VirtualizedList = typeof $$VirtualizedList;
+export default $$VirtualizedList;

package/types_generated/Libraries/Lists/VirtualizedSectionList.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @generated SignedSource<<c1233e12972eb82366e001ff596a7100>>
+ *
+ * This file was translated from Flow by scripts/js-api/build-types/index.js.
+ * Original file: packages/react-native/Libraries/Lists/VirtualizedSectionList.js
+ */
+
+import VirtualizedLists from "@react-native-tvos/virtualized-lists";
+import * as React from "react";
+type VirtualizedSectionListType = typeof VirtualizedLists.VirtualizedSectionList;
+declare const VirtualizedSectionList: VirtualizedSectionListType;
+export type VirtualizedSectionListInstance = React.ComponentRef<VirtualizedSectionListType>;
+export type { SectionBase, ScrollToLocationParamsType, VirtualizedSectionListProps } from "@react-native-tvos/virtualized-lists";
+declare const $$VirtualizedSectionList: typeof VirtualizedSectionList;
+declare type $$VirtualizedSectionList = typeof $$VirtualizedSectionList;
+export default $$VirtualizedSectionList;

package/types_generated/Libraries/LogBox/Data/LogBoxData.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @generated SignedSource<<0ebce2700d71eb2aef77d8387b45c552>>
+ *
+ * This file was translated from Flow by scripts/js-api/build-types/index.js.
+ * Original file: packages/react-native/Libraries/LogBox/Data/LogBoxData.js
+ */
+
+import type { ExtendedError } from "../../Core/ExtendedError";
+import type { LogLevel } from "./LogBoxLog";
+import type { Stack } from "./LogBoxSymbolication";
+import type { Category, ExtendedExceptionData, Message } from "./parseLogBoxLog";
+import LogBoxLog from "./LogBoxLog";
+import * as React from "react";
+export type LogBoxLogs = Set<LogBoxLog>;
+export type LogData = Readonly<{
+  level: LogLevel;
+  message: Message;
+  category: Category;
+  componentStack: Stack;
+  stack?: string | undefined;
+}>;
+export type Observer = ($$PARAM_0$$: Readonly<{
+  logs: LogBoxLogs;
+  isDisabled: boolean;
+  selectedLogIndex: number;
+}>) => void;
+export type IgnorePattern = string | RegExp;
+export type Subscription = Readonly<{
+  unsubscribe: () => void;
+}>;
+export type WarningInfo = {
+  finalFormat: string;
+  forceDialogImmediately: boolean;
+  suppressDialog_LEGACY: boolean;
+  suppressCompletely: boolean;
+  monitorEvent: string | null;
+  monitorListVersion: number;
+  monitorSampleRate: number;
+};
+export type WarningFilter = (format: string) => WarningInfo;
+type AppInfo = Readonly<{
+  appVersion: string;
+  engine: string;
+  onPress?: (() => void) | undefined;
+}>;
+declare let logs: LogBoxLogs;
+export declare function reportLogBoxError(error: ExtendedError, componentStack?: string): void;
+export declare function isLogBoxErrorMessage(message: string): boolean;
+export declare function isMessageIgnored(message: string): boolean;
+export declare function addLog(log: LogData): void;
+export declare function addException(error: ExtendedExceptionData): void;
+export declare function symbolicateLogNow(log: LogBoxLog): void;
+export declare function retrySymbolicateLogNow(log: LogBoxLog): void;
+export declare function symbolicateLogLazy(log: LogBoxLog): void;
+export declare function clear(): void;
+export declare function setSelectedLog(proposedNewIndex: number): void;
+export declare function clearWarnings(): void;
+export declare function clearErrors(): void;
+export declare function dismiss(log: LogBoxLog): void;
+export declare function setWarningFilter(filter: WarningFilter): void;
+export declare function setAppInfo(info: () => AppInfo): void;
+export declare function getAppInfo(): null | undefined | AppInfo;
+export declare function checkWarningFilter(format: string): WarningInfo;
+export declare function getIgnorePatterns(): ReadonlyArray<IgnorePattern>;
+export declare function addIgnorePatterns(patterns: ReadonlyArray<IgnorePattern>): void;
+export declare function setDisabled(value: boolean): void;
+export declare function isDisabled(): boolean;
+export declare function observe(observer: Observer): Subscription;
+type SubscribedComponent = React.ComponentType<Readonly<{
+  logs: ReadonlyArray<LogBoxLog>;
+  isDisabled: boolean;
+  selectedLogIndex: number;
+}>>;
+export declare function withSubscription(WrappedComponent: SubscribedComponent): React.ComponentType<{}>;

package/types_generated/Libraries/LogBox/Data/LogBoxLog.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @generated SignedSource<<ae7d74da1108d7dc68c0c7819b1c5f1c>>
+ *
+ * This file was translated from Flow by scripts/js-api/build-types/index.js.
+ * Original file: packages/react-native/Libraries/LogBox/Data/LogBoxLog.js
+ */
+
+import type { Stack } from "./LogBoxSymbolication";
+import type { Category, CodeFrame, Message } from "./parseLogBoxLog";
+type SymbolicationStatus = "NONE" | "PENDING" | "COMPLETE" | "FAILED";
+type SymbolicationState = Readonly<{
+  error: null;
+  stack: null;
+  status: "NONE";
+}> | Readonly<{
+  error: null;
+  stack: null;
+  status: "PENDING";
+}> | Readonly<{
+  error: null;
+  stack: Stack;
+  status: "COMPLETE";
+}> | Readonly<{
+  error: Error;
+  stack: null;
+  status: "FAILED";
+}>;
+export type LogLevel = "warn" | "error" | "fatal" | "syntax";
+export type LogBoxLogData = Readonly<{
+  level: LogLevel;
+  type?: string | undefined;
+  message: Message;
+  stack: Stack;
+  category: string;
+  componentStack: Stack;
+  codeFrame?: CodeFrame | undefined;
+  isComponentError: boolean;
+  extraData?: unknown | undefined;
+  onNotificationPress?: (() => void) | undefined;
+}>;
+declare class LogBoxLog {
+  message: Message;
+  type: null | undefined | string;
+  category: Category;
+  componentStack: Stack;
+  stack: Stack;
+  count: number;
+  level: LogLevel;
+  codeFrame: null | undefined | CodeFrame;
+  componentCodeFrame: null | undefined | CodeFrame;
+  isComponentError: boolean;
+  extraData: unknown | void;
+  symbolicated: SymbolicationState;
+  symbolicatedComponentStack: SymbolicationState;
+  onNotificationPress: null | undefined | (() => void);
+  constructor(data: LogBoxLogData);
+  incrementCount(): void;
+  getAvailableStack(): Stack;
+  getAvailableComponentStack(): Stack;
+  retrySymbolicate(callback?: (status: SymbolicationStatus) => void): void;
+  symbolicate(callback?: (status: SymbolicationStatus) => void): void;
+  handleSymbolicate(callback?: (status: SymbolicationStatus) => void): void;
+  updateStatus(error: null | undefined | Error, stack: null | undefined | Stack, codeFrame: null | undefined | CodeFrame, callback?: (status: SymbolicationStatus) => void): void;
+  updateComponentStackStatus(error: null | undefined | Error, stack: null | undefined | Stack, codeFrame: null | undefined | CodeFrame, callback?: (status: SymbolicationStatus) => void): void;
+}
+export default LogBoxLog;