@fluentui-react-native/callout 0.28.0 → 0.28.3

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 # Change Log - @fluentui-react-native/callout
 
+## 0.28.3
+
+### Patch Changes
+
+- 9cf4444: Migrate from ESLint to oxlint
+- Updated dependencies [9cf4444]
+  - @uifabricshared/foundation-composable@0.14.3
+  - @uifabricshared/foundation-settings@0.16.3
+  - @uifabricshared/foundation-compose@1.16.3
+  - @fluentui-react-native/adapters@0.14.3
+  - @fluentui-react-native/tokens@0.24.3
+
+## 0.28.2
+
+### Patch Changes
+
+- 8a7b549: Update to the latest rnx-kit versions, fix some typing issues, and correct the vscode settings
+- Updated dependencies [8a7b549]
+  - @uifabricshared/foundation-composable@0.14.2
+  - @uifabricshared/foundation-settings@0.16.2
+  - @uifabricshared/foundation-compose@1.16.2
+  - @fluentui-react-native/adapters@0.14.2
+  - @fluentui-react-native/tokens@0.24.2
+
+## 0.28.1
+
+### Patch Changes
+
+- f72b43a: Fix codegen definitions for native components in repo
+- 0d6e9c1: chore: migrate to `oxfmt`
+- ac6e7af: Ensure packages have a default export that references the typescript entrypoint and clean up build dependency ordering
+- Updated dependencies [0d6e9c1]
+- Updated dependencies [ac6e7af]
+  - @uifabricshared/foundation-composable@0.14.1
+  - @uifabricshared/foundation-settings@0.16.1
+  - @uifabricshared/foundation-compose@1.16.1
+  - @fluentui-react-native/adapters@0.14.1
+  - @fluentui-react-native/tokens@0.24.1
+
 ## 0.28.0
 
 ### Minor Changes

package/lib/Callout.d.ts

@@ -4,12 +4,6 @@
  * @format
  */
 import type { ICalloutProps, ICalloutSlotProps } from './Callout.types';
-export declare const Callout: import('@uifabricshared/foundation-compose').IComposeReturnType<
-  ICalloutProps,
-  ICalloutSlotProps,
-  import('./Callout.types').ICalloutTokens,
-  object,
-  object
->;
+export declare const Callout: import("@uifabricshared/foundation-compose").IComposeReturnType<ICalloutProps, ICalloutSlotProps, import("./Callout.types").ICalloutTokens, object, object>;
 export default Callout;
-//# sourceMappingURL=Callout.d.ts.map
+//# sourceMappingURL=Callout.d.ts.map

package/lib/Callout.js

@@ -13,55 +13,53 @@ import { calloutName } from './Callout.types';
 import NativeCalloutView from './CalloutNativeComponent';
 import { Commands } from './CalloutNativeComponent';
 export const Callout = compose({
-  displayName: calloutName,
-  usePrepareProps: (props, useStyling) => {
-    const { componentRef, target, ...rest } = props;
-    React.useImperativeHandle(
-      componentRef,
-      () => ({
-        blurWindow() {
-          if (componentRef.current != null) {
-            Commands.blurWindow(nativeComponentRef.current);
-          }
-        },
-        focusWindow() {
-          if (componentRef.current != null) {
-            Commands.focusWindow(nativeComponentRef.current);
-          }
-        },
-      }),
-      [componentRef],
-    );
-    const nativeComponentRef = React.useRef(null);
-    const [nativeTarget, setNativeTarget] = React.useState(null);
-    React.useLayoutEffect(() => {
-      if (typeof target === 'string') {
-        // Pass string type `target` directly
-        setNativeTarget(target);
-      } else if (target?.current) {
-        // Pass the tagID for a valid ref `target`
-        setNativeTarget(findNodeHandle(target.current));
-      } else {
-        // Clear `target` so we may fall back on `anchorRect` if provided
-        setNativeTarget(null);
-      }
-    }, [target]);
-    const slotProps = mergeSettings(useStyling(props), {
-      root: {
-        ref: nativeComponentRef,
-        ...(nativeTarget && { target: nativeTarget }),
-        ...rest,
-      },
-    });
-    return { slotProps };
-  },
-  settings: settings,
-  slots: {
-    root: NativeCalloutView,
-  },
-  styles: {
-    root: [backgroundColorTokens, borderTokens],
-  },
+    displayName: calloutName,
+    usePrepareProps: (props, useStyling) => {
+        const { componentRef, target, ...rest } = props;
+        React.useImperativeHandle(componentRef, () => ({
+            blurWindow() {
+                if (componentRef.current != null) {
+                    Commands.blurWindow(nativeComponentRef.current);
+                }
+            },
+            focusWindow() {
+                if (componentRef.current != null) {
+                    Commands.focusWindow(nativeComponentRef.current);
+                }
+            },
+        }), [componentRef]);
+        const nativeComponentRef = React.useRef(null);
+        const [nativeTarget, setNativeTarget] = React.useState(null);
+        React.useLayoutEffect(() => {
+            if (typeof target === 'string') {
+                // Pass string type `target` directly
+                setNativeTarget(target);
+            }
+            else if (target?.current) {
+                // Pass the tagID for a valid ref `target`
+                setNativeTarget(findNodeHandle(target.current));
+            }
+            else {
+                // Clear `target` so we may fall back on `anchorRect` if provided
+                setNativeTarget(null);
+            }
+        }, [target]);
+        const slotProps = mergeSettings(useStyling(props), {
+            root: {
+                ref: nativeComponentRef,
+                ...(nativeTarget && { target: nativeTarget }),
+                ...rest,
+            },
+        });
+        return { slotProps };
+    },
+    settings: settings,
+    slots: {
+        root: NativeCalloutView,
+    },
+    styles: {
+        root: [backgroundColorTokens, borderTokens],
+    },
 });
 export default Callout;
-//# sourceMappingURL=Callout.js.map
+//# sourceMappingURL=Callout.js.map

package/lib/Callout.settings.d.ts

@@ -1,4 +1,4 @@
 import type { IComposeSettings } from '@uifabricshared/foundation-compose';
 import type { ICalloutType } from './Callout.types';
 export declare const settings: IComposeSettings<ICalloutType>;
-//# sourceMappingURL=Callout.settings.d.ts.map
+//# sourceMappingURL=Callout.settings.d.ts.map

package/lib/Callout.settings.js

@@ -1,16 +1,16 @@
 import { calloutName } from './Callout.types';
 export const settings = [
-  {
-    tokens: {
-      backgroundColor: 'bodyStandoutBackground',
-      beakWidth: 20,
-      borderColor: 'bodyFrameBackground',
-      borderWidth: 1,
-      directionalHint: 'bottonLeftEdge',
-      gapSpace: 0,
-      minPadding: 0,
+    {
+        tokens: {
+            backgroundColor: 'bodyStandoutBackground',
+            beakWidth: 20,
+            borderColor: 'bodyFrameBackground',
+            borderWidth: 1,
+            directionalHint: 'bottonLeftEdge',
+            gapSpace: 0,
+            minPadding: 0,
+        },
     },
-  },
-  calloutName,
+    calloutName,
 ];
-//# sourceMappingURL=Callout.settings.js.map
+//# sourceMappingURL=Callout.settings.js.map

package/lib/Callout.settings.macos.d.ts

@@ -1,4 +1,4 @@
 import type { IComposeSettings } from '@uifabricshared/foundation-compose';
 import type { ICalloutType } from './Callout.types';
 export declare const settings: IComposeSettings<ICalloutType>;
-//# sourceMappingURL=Callout.settings.macos.d.ts.map
+//# sourceMappingURL=Callout.settings.macos.d.ts.map

package/lib/Callout.settings.macos.js

@@ -1,19 +1,19 @@
 import { calloutName } from './Callout.types';
 export const settings = [
-  {
-    tokens: {
-      backgroundColor: 'bodyStandoutBackground',
-      borderColor: 'transparent',
-      borderWidth: 0,
-      borderRadius: 5,
-      directionalHint: 'bottonLeftEdge',
+    {
+        tokens: {
+            backgroundColor: 'bodyStandoutBackground',
+            borderColor: 'transparent',
+            borderWidth: 0,
+            borderRadius: 5,
+            directionalHint: 'bottonLeftEdge',
+        },
+        root: {
+            style: {
+                position: 'absolute',
+            },
+        },
     },
-    root: {
-      style: {
-        position: 'absolute',
-      },
-    },
-  },
-  calloutName,
+    calloutName,
 ];
-//# sourceMappingURL=Callout.settings.macos.js.map
+//# sourceMappingURL=Callout.settings.macos.js.map

package/lib/Callout.types.d.ts

@@ -1,233 +1,186 @@
 import type * as React from 'react';
-import type { KeyboardMetrics, ViewStyle, ViewProps } from 'react-native';
+import type { KeyboardMetrics, ViewStyle } from 'react-native';
 import type { IViewProps } from '@fluentui-react-native/adapters';
 import type { IBackgroundColorTokens, IBorderTokens } from '@fluentui-react-native/tokens';
 import type { IRenderData } from '@uifabricshared/foundation-composable';
-import type { CalloutNativeCommands } from './CalloutNativeComponent.types';
-export declare const calloutName = 'Callout';
-import type { DirectEventHandler, Double, Int32 } from 'react-native/Libraries/Types/CodegenTypes';
+import type { CalloutNativeCommands } from './CalloutNativeComponent';
+export declare const calloutName = "Callout";
 /**
  * Properties and Tokens for FluentUI React Native Callout
  */
-export type DirectionalHint =
-  | 'leftTopEdge'
-  | 'leftCenter'
-  | 'leftBottomEdge'
-  | 'topLeftEdge'
-  | 'topAutoEdge'
-  | 'topCenter'
-  | 'topRightEdge'
-  | 'rightTopEdge'
-  | 'rightCenter'
-  | 'rightBottomEdge'
-  | 'bottonLeftEdge'
-  | 'bottomAutoEdge'
-  | 'bottomCenter'
-  | 'bottomRightEdge';
+export type DirectionalHint = 'leftTopEdge' | 'leftCenter' | 'leftBottomEdge' | 'topLeftEdge' | 'topAutoEdge' | 'topCenter' | 'topRightEdge' | 'rightTopEdge' | 'rightCenter' | 'rightBottomEdge' | 'bottomLeftEdge' | 'bottonLeftEdge' | 'bottomAutoEdge' | 'bottomCenter' | 'bottomRightEdge';
 export type DismissBehaviors = 'preventDismissOnKeyDown' | 'preventDismissOnClickOutside';
 export interface RestoreFocusEvent {
-  nativeEvent: {
-    /**
-     * containsFocus is true if the Callout had focus while being dismissed.
-     */
-    containsFocus: boolean;
-  };
+    nativeEvent: {
+        /**
+         * containsFocus is true if the Callout had focus while being dismissed.
+         */
+        containsFocus: boolean;
+    };
 }
 interface OmittedBorderTokens {
-  borderStyle?: ViewStyle['borderStyle'];
+    borderStyle?: ViewStyle['borderStyle'];
 }
 type CalloutBorderTokens = Omit<IBorderTokens, keyof OmittedBorderTokens>;
 export interface ICalloutTokens extends IBackgroundColorTokens, CalloutBorderTokens {
-  /**
-   * AnchorRect arbitrary anchor rectangle; coordinate system is in DIPs, relative
-   * to the React surface origin.
-   */
-  anchorRect?: KeyboardMetrics;
-  /**
-   * Width of the beak on the Callout indicating its anchor.
-   */
-  beakWidth?: number;
-  /**
-   * Defines the suggested drop direction and alignment for the Callout to use, relative
-   * to the anchor information.
-   */
-  directionalHint?: DirectionalHint;
-  /**
-   * Defines variations on how the callout dismissal may be controlled.  the async eventing
-   * of React-Native makes passing some aspects of dismissal control over to JS difficult.
-   * Moreover, the native platform or host may have competing priorities with regards to transient UI
-   * that generate bi-directional lifetime management between JS (which mounts and unmounts the
-   * component) and native (which may tear down the transient UI without JS input).
-   *
-   * This property provides control over the latter issue, enabling relevant native platform
-   * interactions with transient UI to be managed from JS.
-   *
-   * These behaviors should generally be orthogonal, and therefore combinable.
-   */
-  dismissBehaviors?: DismissBehaviors[];
-  /**
-   * Defines the size of the gap between the anchor and the Callout.  Not used if
-   * no anchor information is provided.
-   */
-  gapSpace?: number;
-  /**
-   * Defines a maximum height for the Callout.
-   */
-  maxHeight?: number | `${number}%`;
-  /**
-   * Defines a maximum width for the Callout.
-   */
-  maxWidth?: number | `${number}%`;
-  /**
-   * Defines a minimum width for the Callout.
-   */
-  minWidth?: number | `${number}%`;
-  /**
-   * Defines the minimum padding between the Callout and the display edges.
-   */
-  minPadding?: number;
+    /**
+     * AnchorRect arbitrary anchor rectangle; coordinate system is in DIPs, relative
+     * to the React surface origin.
+     */
+    anchorRect?: KeyboardMetrics;
+    /**
+     * Width of the beak on the Callout indicating its anchor.
+     */
+    beakWidth?: number;
+    /**
+     * Defines the suggested drop direction and alignment for the Callout to use, relative
+     * to the anchor information.
+     */
+    directionalHint?: DirectionalHint;
+    /**
+     * Defines variations on how the callout dismissal may be controlled.  the async eventing
+     * of React-Native makes passing some aspects of dismissal control over to JS difficult.
+     * Moreover, the native platform or host may have competing priorities with regards to transient UI
+     * that generate bi-directional lifetime management between JS (which mounts and unmounts the
+     * component) and native (which may tear down the transient UI without JS input).
+     *
+     * This property provides control over the latter issue, enabling relevant native platform
+     * interactions with transient UI to be managed from JS.
+     *
+     * These behaviors should generally be orthogonal, and therefore combinable.
+     */
+    dismissBehaviors?: DismissBehaviors[];
+    /**
+     * Defines the size of the gap between the anchor and the Callout.  Not used if
+     * no anchor information is provided.
+     */
+    gapSpace?: number;
+    /**
+     * Defines a maximum height for the Callout.
+     */
+    maxHeight?: number | `${number}%`;
+    /**
+     * Defines a maximum width for the Callout.
+     */
+    maxWidth?: number | `${number}%`;
+    /**
+     * Defines a minimum width for the Callout.
+     */
+    minWidth?: number | `${number}%`;
+    /**
+     * Defines the minimum padding between the Callout and the display edges.
+     */
+    minPadding?: number;
 }
 export interface ICalloutProps extends IViewProps, ICalloutTokens {
-  /**
-   * A string that should be announced when the callout is shown.
-   * @platform win32
-   */
-  accessibilityOnShowAnnouncement?: string;
-  /**
-   * A RefObject to access the IFocusable interface. Use this to access the public methods and properties of the component.
-   */
-  componentRef?: React.RefObject<CalloutNativeCommands>;
-  /**
-   * Defines event redirection behaviors for pointer events relative to the Callout control.
-   *
-   * Pointer events (i.e. mouse, pen, touch) often have the effect of initiating and dismissing Callout controls.
-   * Typically the instigating events are click events, but when using a mouse may also include pointer enter
-   * and leave events i.e. hover.  Once opened, many Callout scenarios desire modal-like interactions, where
-   * the user must interact with or relative to the Callout before interacting with other controls again. A common
-   * example is context menus, where pointer events away from the menu may dismiss the context menu.  Such an interaction
-   * can initiate unintended actions such as invoking a button or otherwise pointer-responsive surface.  The modal-like
-   * behavior is the most common case of Callout usage, and having "safe" areas to press-dismiss the Callout without
-   * invoking additional actions is useful.
-   *
-   * This modal-like behavior, where true modal behavior would specifically require interacting with the modal component until
-   * it is dismissed, has implications for canonical event routing in React-Native.  Canonically all pointer events are passed in
-   * a Capture phase from the root element to the target element, then bubbled back from the target element to the root element.
-   * This structure allows many interaction patterns to be implemented that may include stopping event routing in each phase.
-   * This event routing can disrupt the modal-like behavior desired by a Callout control, which in native frameworks may take
-   * advantage of a "take event capture" feature -- making the Callout the first handler of the pointer event.  The event may optionally
-   * be forwarded afterwards to the canonical event routing pattern for further handling (and often is not forwarded).
-   *
-   * One impact of "taking event capture" is the implicit behavior for mouse events on the parent surface of the Callout -- if
-   * event capture is taken by the Callout, paired events may fire such as a mouse leave event.  This makes sense if we think about
-   * the event behavior after the Callout has taken capture; mouse enter and mouse leave events would only propagate to the parent surface
-   * if the Callout event handling decided to forward said events (often not).  As paired events, however, there should not be a
-   * mouse enter event without a corresponding mouse leave event (or vice versa).  Since mouse enter and mouse leave events would not
-   * naturally fire on the parent surface when the Callout has pointer capture, the parent surface should receive a mouse leave event when
-   * the Callout takes capture.
-   *
-   * Coming back to the start of this comment, some Callout scenarios may be initiated by mouse enter/leave events.  A common example is
-   * tooltips, which are supported on lower-level React-Native components, but such behavior is not exclusive to tooltips.
-   * The Callout control is generally used for more advanced scenarios, as mentioned before often desiring modal-like behavior and accordingly
-   * the default behavior of the Callout control is to take pointer capture.  Accounting for the paired mouse enter/leave events in the paragraph
-   * above, it is difficult to have a mouse enter/leave-invoked Callout that takes pointer capture -- without significant workarounds,
-   * the Callout would open and close cyclically from repeated mouse enter/leave events.  There are other scenarios where taking pointer capture
-   * is not desirable, such as a semi-persistent Callout; to support these scenarios the doNotTakePointerCapture property is offered to
-   * specify if the Callout should not take pointer capture when it opens.
-   *
-   * While pointer capture is generally managed in native frameworks via imperative APIs, managing pointer capture is offered as a property that
-   * only affects the Callout's on-show behavior when it would typically take pointer capture.  This design implies that changing this property after
-   * the Callout has been shown has no effect -- similar to the Callout's onShow callback.  Doing so simplifies Callout usage for developers,
-   * not needing to mind native platform pointer capture that may be complex particularly when React-Native is integrated into a larger app.
-   * Pointer capture may be lost (and regained) but is otherwise abstracted away from the developer.  More advanced control of pointer capture
-   * would need to be provided by a native module independent of any particular control.
-   *
-   * When the Callout is closed, pointer capture is released by the Callout and further handled by the native platform -- generally returning
-   * pointer capture to the parent surface.
-   * @platform win32
-   */
-  doNotTakePointerCapture?: boolean;
-  /**
-   * Adds a beak to the Callout, pointing to the anchor target.
-   * Notable Win32 limitation: Beak rendering currently limits the border width to its default, and the
-   * border width prop will not be honored.
-   * @platform win32
-   */
-  isBeakVisible?: boolean;
-  /**
-   * Callback invoked when the callout has been dismissed.
-   */
-  onDismiss?: () => void;
-  /**
-   * Callback invoked during callout dismissal; if set, focus will not be restored by the callout and onRestoreFocus must
-   * result in focus being moved to the appropriate focusable target.
-   *
-   * The callee should carefully consider their scenarios to avoid dropping focus, or inappropriately
-   * moving focus from another component.  Focus is not guaranteed to have entered the React-Native surface at all, and
-   * this callback is most appropriate for components strictly controlling focus.
-   *
-   * restoreFocusEvent.nativeEvent.containsFocus is true if the Callout had focus while being dismissed.
-   * @platform win32
-   */
-  onRestoreFocus?: (restoreFocusEvent: RestoreFocusEvent) => void;
-  /**
-   * Callback invoked when the callout has been shown.
-   */
-  onShow?: () => void;
-  /**
-   * Determines whether the Callout sets focus when displayed.
-   * On macOS: this determines whether the Callout becomes the key window.
-   * On win32: If true then the callout will attempt to focus the first focusable element that it contains.
-   * If it doesn't find an element, no focus will be set. This means that it's the contents responsibility
-   * to either set focus or have focusable items.
-   */
-  setInitialFocus?: boolean;
-  /**
-   * Target node the callout uses for relative positioning; the anchor of the callout.
-   * A ref is the typical usage; certain components may proffer a string as an anchor target, such as
-   * anchoring to a point inside the component.
-   */
-  target?: React.RefObject<React.Component> | string;
+    /**
+     * A string that should be announced when the callout is shown.
+     * @platform win32
+     */
+    accessibilityOnShowAnnouncement?: string;
+    /**
+     * A RefObject to access the IFocusable interface. Use this to access the public methods and properties of the component.
+     */
+    componentRef?: React.RefObject<CalloutNativeCommands>;
+    /**
+     * Defines event redirection behaviors for pointer events relative to the Callout control.
+     *
+     * Pointer events (i.e. mouse, pen, touch) often have the effect of initiating and dismissing Callout controls.
+     * Typically the instigating events are click events, but when using a mouse may also include pointer enter
+     * and leave events i.e. hover.  Once opened, many Callout scenarios desire modal-like interactions, where
+     * the user must interact with or relative to the Callout before interacting with other controls again. A common
+     * example is context menus, where pointer events away from the menu may dismiss the context menu.  Such an interaction
+     * can initiate unintended actions such as invoking a button or otherwise pointer-responsive surface.  The modal-like
+     * behavior is the most common case of Callout usage, and having "safe" areas to press-dismiss the Callout without
+     * invoking additional actions is useful.
+     *
+     * This modal-like behavior, where true modal behavior would specifically require interacting with the modal component until
+     * it is dismissed, has implications for canonical event routing in React-Native.  Canonically all pointer events are passed in
+     * a Capture phase from the root element to the target element, then bubbled back from the target element to the root element.
+     * This structure allows many interaction patterns to be implemented that may include stopping event routing in each phase.
+     * This event routing can disrupt the modal-like behavior desired by a Callout control, which in native frameworks may take
+     * advantage of a "take event capture" feature -- making the Callout the first handler of the pointer event.  The event may optionally
+     * be forwarded afterwards to the canonical event routing pattern for further handling (and often is not forwarded).
+     *
+     * One impact of "taking event capture" is the implicit behavior for mouse events on the parent surface of the Callout -- if
+     * event capture is taken by the Callout, paired events may fire such as a mouse leave event.  This makes sense if we think about
+     * the event behavior after the Callout has taken capture; mouse enter and mouse leave events would only propagate to the parent surface
+     * if the Callout event handling decided to forward said events (often not).  As paired events, however, there should not be a
+     * mouse enter event without a corresponding mouse leave event (or vice versa).  Since mouse enter and mouse leave events would not
+     * naturally fire on the parent surface when the Callout has pointer capture, the parent surface should receive a mouse leave event when
+     * the Callout takes capture.
+     *
+     * Coming back to the start of this comment, some Callout scenarios may be initiated by mouse enter/leave events.  A common example is
+     * tooltips, which are supported on lower-level React-Native components, but such behavior is not exclusive to tooltips.
+     * The Callout control is generally used for more advanced scenarios, as mentioned before often desiring modal-like behavior and accordingly
+     * the default behavior of the Callout control is to take pointer capture.  Accounting for the paired mouse enter/leave events in the paragraph
+     * above, it is difficult to have a mouse enter/leave-invoked Callout that takes pointer capture -- without significant workarounds,
+     * the Callout would open and close cyclically from repeated mouse enter/leave events.  There are other scenarios where taking pointer capture
+     * is not desirable, such as a semi-persistent Callout; to support these scenarios the doNotTakePointerCapture property is offered to
+     * specify if the Callout should not take pointer capture when it opens.
+     *
+     * While pointer capture is generally managed in native frameworks via imperative APIs, managing pointer capture is offered as a property that
+     * only affects the Callout's on-show behavior when it would typically take pointer capture.  This design implies that changing this property after
+     * the Callout has been shown has no effect -- similar to the Callout's onShow callback.  Doing so simplifies Callout usage for developers,
+     * not needing to mind native platform pointer capture that may be complex particularly when React-Native is integrated into a larger app.
+     * Pointer capture may be lost (and regained) but is otherwise abstracted away from the developer.  More advanced control of pointer capture
+     * would need to be provided by a native module independent of any particular control.
+     *
+     * When the Callout is closed, pointer capture is released by the Callout and further handled by the native platform -- generally returning
+     * pointer capture to the parent surface.
+     * @platform win32
+     */
+    doNotTakePointerCapture?: boolean;
+    /**
+     * Adds a beak to the Callout, pointing to the anchor target.
+     * Notable Win32 limitation: Beak rendering currently limits the border width to its default, and the
+     * border width prop will not be honored.
+     * @platform win32
+     */
+    isBeakVisible?: boolean;
+    /**
+     * Callback invoked when the callout has been dismissed.
+     */
+    onDismiss?: () => void;
+    /**
+     * Callback invoked during callout dismissal; if set, focus will not be restored by the callout and onRestoreFocus must
+     * result in focus being moved to the appropriate focusable target.
+     *
+     * The callee should carefully consider their scenarios to avoid dropping focus, or inappropriately
+     * moving focus from another component.  Focus is not guaranteed to have entered the React-Native surface at all, and
+     * this callback is most appropriate for components strictly controlling focus.
+     *
+     * restoreFocusEvent.nativeEvent.containsFocus is true if the Callout had focus while being dismissed.
+     * @platform win32
+     */
+    onRestoreFocus?: (restoreFocusEvent: RestoreFocusEvent) => void;
+    /**
+     * Callback invoked when the callout has been shown.
+     */
+    onShow?: () => void;
+    /**
+     * Determines whether the Callout sets focus when displayed.
+     * On macOS: this determines whether the Callout becomes the key window.
+     * On win32: If true then the callout will attempt to focus the first focusable element that it contains.
+     * If it doesn't find an element, no focus will be set. This means that it's the contents responsibility
+     * to either set focus or have focusable items.
+     */
+    setInitialFocus?: boolean;
+    /**
+     * Target node the callout uses for relative positioning; the anchor of the callout.
+     * A ref is the typical usage; certain components may proffer a string as an anchor target, such as
+     * anchoring to a point inside the component.
+     */
+    target?: React.RefObject<React.Component> | string;
 }
 export type ICalloutSlotProps = {
-  root: ICalloutProps;
+    root: ICalloutProps;
 };
 export type ICalloutRenderData = IRenderData<ICalloutSlotProps>;
 export interface ICalloutType {
-  props: ICalloutProps;
-  slotProps: ICalloutSlotProps;
-  tokens: ICalloutTokens;
-}
-type AnchorRect = {
-  screenX: Double;
-  screenY: Double;
-  width: Double;
-  height: Double;
-};
-/**
- * Shared native props specific to Callout native component
- */
-export interface NativePropsBase extends ViewProps {
-  accessibilityLabel?: string;
-  accessibilityOnShowAnnouncement?: string;
-  anchorRect?: AnchorRect;
-  dismissBehaviors?: string[];
-  doNotTakePointerCapture?: boolean;
-  focusable?: boolean;
-  isBeakVisible?: boolean;
-  maxHeight?: Int32;
-  maxWidth?: Int32;
-  setInitialFocus?: boolean;
-  testID?: string;
-  onRestoreFocus?: DirectEventHandler<{
-    target: Int32;
-    containsFocus: boolean;
-  }>;
-  onDismiss?: DirectEventHandler<{
-    target: Int32;
-  }>;
-  onShow?: DirectEventHandler<{
-    target: Int32;
-  }>;
+    props: ICalloutProps;
+    slotProps: ICalloutSlotProps;
+    tokens: ICalloutTokens;
 }
 export {};
-//# sourceMappingURL=Callout.types.d.ts.map
+//# sourceMappingURL=Callout.types.d.ts.map