react-native-tvos 0.81.4-0 → 0.81.5-0

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

@@ -1,317 +0,0 @@
-/**
- * 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<<ecbd6745575781c8a33e39cbd72a5484>>
- *
- * This file was translated from Flow by scripts/build-types/index.js.
- * Original file: packages/react-native/Libraries/Lists/FlatList.js
- */
-
-import type $$IMPORT_TYPEOF_1$$ from "../Components/ScrollView/ScrollViewNativeComponent";
-type ScrollViewNativeComponent = typeof $$IMPORT_TYPEOF_1$$;
-import type { ViewStyleProp } from "../StyleSheet/StyleSheet";
-import type { ListRenderItem, VirtualizedListProps } from "@react-native-tvos/virtualized-lists";
-import { type ScrollResponderType } from "../Components/ScrollView/ScrollView";
-import View from "../Components/View/View";
-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;
-  /**
-   * 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;
-  /**
-   * `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;
-  };
-  /**
-   * 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;
-  /**
-   * 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;
-  /**
-   * See `ScrollView` for flow type and further documentation.
-   */
-  fadingEdgeLength?: (number | undefined) | {
-    start: number;
-    end: number;
-  };
-  /**
-   * Enable an optimization to memoize the item renderer to prevent unnecessary rerenders.
-   */
-  strictMode?: boolean;
-};
-type FlatListBaseProps<ItemT> = Omit<RequiredFlatListProps<ItemT>, keyof OptionalFlatListProps<ItemT> | keyof {}> & Omit<OptionalFlatListProps<ItemT>, keyof {}> & {};
-export type FlatListProps<ItemT> = 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;
-    viewPosition?: number;
-  }): 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;
-    viewPosition?: number;
-  }): 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 | React.ComponentRef<typeof View>) | (null | undefined | React.ComponentRef<ScrollViewNativeComponent>);
-  getScrollableNode(): any;
-  setNativeProps(props: {
-    [$$Key$$: string]: unknown;
-  }): void;
-  constructor(props: FlatListProps<ItemT>);
-  componentDidUpdate(prevProps: FlatListProps<ItemT>): void;
-  render(): React.ReactNode;
-}
-export default FlatList;

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

@@ -1,172 +0,0 @@
-/**
- * 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<<be5b6b22b57a335dda71e2f53505cd12>>
- *
- * This file was translated from Flow by scripts/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>, keyof {
-  section: SectionData<ItemT, SectionT>;
-}> & {
-  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>;
-  /**
-   * 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;
-  /**
-   * 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;
-};
-export type SectionListProps<ItemT, SectionT = DefaultSectionT> = 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.
- *
- */
-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;
-  getScrollableNode(): any;
-  setNativeProps(props: Object): void;
-  render(): React.ReactNode;
-}
-export default SectionList;

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

@@ -1,19 +0,0 @@
-/**
- * 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<<8f252fe8b2954e3ae8fe817a89f5a661>>
- *
- * This file was translated from Flow by scripts/build-types/index.js.
- * Original file: packages/react-native/Libraries/Lists/VirtualizedList.js
- */
-
-import VirtualizedLists from "@react-native-tvos/virtualized-lists";
-type VirtualizedListType = typeof VirtualizedLists.VirtualizedList;
-declare const VirtualizedListComponent: VirtualizedListType;
-export type { ListRenderItemInfo, ListRenderItem, 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

@@ -1,19 +0,0 @@
-/**
- * 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<<a2a38e951283729628053ade6b95fdb9>>
- *
- * This file was translated from Flow by scripts/build-types/index.js.
- * Original file: packages/react-native/Libraries/Lists/VirtualizedSectionList.js
- */
-
-import VirtualizedLists from "@react-native-tvos/virtualized-lists";
-type VirtualizedSectionListType = typeof VirtualizedLists.VirtualizedSectionList;
-declare const VirtualizedSectionList: 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

@@ -1,78 +0,0 @@
-/**
- * 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<<416339c67e408edf80e10ef9929452c1>>
- *
- * This file was translated from Flow by scripts/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 { Category, ComponentStack, ComponentStackType, 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: ComponentStack;
-  componentStackType: ComponentStackType | null;
-  stack?: string;
-}>;
-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;
-}>;
-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<{}>;