@appsent-co/react-native-watchos 0.1.0

package/src/modifiers/accessibilityElement.ts

@@ -0,0 +1,16 @@
+import { createModifier } from './createModifier';
+
+/// How a SwiftUI accessibility element treats its children.
+/// - `'ignore'` — children are not accessible (the element is a leaf)
+/// - `'combine'` — children are merged into this element
+/// - `'contain'` — children remain individually accessible inside it
+export type AccessibilityChildBehavior = 'ignore' | 'combine' | 'contain';
+
+/// SwiftUI `.accessibilityElement(children:)`. Creates an accessibility
+/// element for the view, controlling how its children participate.
+/// Defaults to `'ignore'`, matching SwiftUI.
+export function accessibilityElement(
+  children: AccessibilityChildBehavior = 'ignore'
+) {
+  return createModifier('accessibilityElement', { children });
+}

package/src/modifiers/accessibilityHidden.ts

@@ -0,0 +1,7 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `.accessibilityHidden(_:)`. When `true` (the default), hides the
+/// view and its children from assistive technologies.
+export function accessibilityHidden(value = true) {
+  return createModifier('accessibilityHidden', { value });
+}

package/src/modifiers/accessibilityHint.ts

@@ -0,0 +1,7 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `.accessibilityHint(_:)`. Describes the result of performing the
+/// view's action, read by VoiceOver after the label.
+export function accessibilityHint(hint: string) {
+  return createModifier('accessibilityHint', { hint });
+}

package/src/modifiers/accessibilityIdentifier.ts

@@ -0,0 +1,7 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `.accessibilityIdentifier(_:)`. Sets a non-localized identifier
+/// used by UI tests to locate the view; not spoken by VoiceOver.
+export function accessibilityIdentifier(identifier: string) {
+  return createModifier('accessibilityIdentifier', { identifier });
+}

package/src/modifiers/accessibilityLabel.ts

@@ -0,0 +1,7 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `.accessibilityLabel(_:)`. Sets the label VoiceOver reads to
+/// identify the view, overriding any inferred label.
+export function accessibilityLabel(label: string) {
+  return createModifier('accessibilityLabel', { label });
+}

package/src/modifiers/accessibilityRemoveTraits.ts

@@ -0,0 +1,11 @@
+import { createModifier } from './createModifier';
+import type { AccessibilityTrait } from './accessibilityAddTraits';
+
+/// SwiftUI `.accessibilityRemoveTraits(_:)`. Removes one or more traits
+/// previously inferred or added. Pass a single trait or an array; an array
+/// is combined into one `AccessibilityTraits`.
+export function accessibilityRemoveTraits(
+  traits: AccessibilityTrait | AccessibilityTrait[]
+) {
+  return createModifier('accessibilityRemoveTraits', { traits });
+}

package/src/modifiers/accessibilityValue.ts

@@ -0,0 +1,7 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `.accessibilityValue(_:)`. Sets the spoken value of the view
+/// (e.g. a slider's current reading) for assistive technologies.
+export function accessibilityValue(value: string) {
+  return createModifier('accessibilityValue', { value });
+}

package/src/modifiers/alert.ts

@@ -0,0 +1,32 @@
+import type { ReactNode } from 'react';
+import { createModifier } from './createModifier';
+
+export interface AlertParams {
+  /// The alert's title text.
+  title: string;
+  /// Whether the alert is shown. JS owns the source of truth; the native
+  /// side mirrors it in local `@State` and converges on the JS value.
+  isPresented: boolean;
+  /// Fired with the new boolean whenever the presentation state changes
+  /// (e.g. an action button or the system dismisses the alert).
+  onChange?: (isPresented: boolean) => void;
+  /// The alert's action buttons (typically `<Button>`s).
+  actions: ReactNode;
+  /// Optional descriptive message shown below the title.
+  message?: ReactNode;
+}
+
+/// SwiftUI `.alert(_:isPresented:actions:message:)`. Presents an alert
+/// titled `title` when `isPresented` is true. `actions` supplies the
+/// buttons and `message` the optional body. The boolean is bound two-way
+/// so a button tap / dismissal reports back to JS via `onChange`.
+export function alert(params: AlertParams) {
+  const { title, isPresented, onChange, actions, message } = params;
+  return createModifier('alert', {
+    title,
+    isPresented,
+    handler: onChange,
+    actions,
+    message,
+  });
+}

package/src/modifiers/alignmentGuide.ts

@@ -0,0 +1,33 @@
+import { createModifier } from './createModifier';
+
+export type AlignmentGuideName =
+  | 'leading'
+  | 'trailing'
+  | 'top'
+  | 'bottom'
+  | 'centerHorizontal'
+  | 'centerVertical'
+  | 'firstTextBaseline'
+  | 'lastTextBaseline';
+
+export interface AlignmentGuideParams {
+  /// Which alignment guide to override. Horizontal guides
+  /// (`leading`/`trailing`/`centerHorizontal`) pair with a parent's
+  /// horizontal alignment; vertical guides (`top`/`bottom`/baselines/
+  /// `centerVertical`) pair with a vertical one.
+  guide: AlignmentGuideName;
+  /// Offset added to the guide's default position, in points. The native
+  /// side computes `defaultGuideValue + offset`.
+  offset?: number;
+}
+
+/// SwiftUI `.alignmentGuide(_:computeValue:)`.
+///
+/// LIMITED: SwiftUI's real `computeValue` is an arbitrary closure over the
+/// view's `ViewDimensions`. A closure cannot cross the JS bridge, so this
+/// exposes a simplified form — pick a named `guide` and a numeric `offset`,
+/// and the native side returns the guide's default value plus that offset.
+/// Custom alignment guides and dimension-relative math are not expressible.
+export function alignmentGuide(params: AlignmentGuideParams) {
+  return createModifier('alignmentGuide', params);
+}

package/src/modifiers/allowsHitTesting.ts

@@ -0,0 +1,8 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `.allowsHitTesting(_:)`. When `false`, the view is invisible to
+/// taps and gestures, which pass through to whatever is behind it. Pass
+/// `true` (the default) to restore normal hit testing.
+export function allowsHitTesting(value: boolean) {
+  return createModifier('allowsHitTesting', { value });
+}

package/src/modifiers/allowsTightening.ts

@@ -0,0 +1,8 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `.allowsTightening(_:)`. When `true`, the view is allowed to
+/// compress inter-character spacing to fit text into the available space
+/// before truncating. Defaults to `true`.
+export function allowsTightening(value: boolean = true) {
+  return createModifier('allowsTightening', { value });
+}

package/src/modifiers/animation.ts

@@ -0,0 +1,38 @@
+import { createModifier } from './createModifier';
+
+export type AnimationCurve =
+  | 'default'
+  | 'easeIn'
+  | 'easeOut'
+  | 'easeInOut'
+  | 'linear'
+  | 'spring'
+  | 'none';
+
+export interface AnimationParams {
+  /// Curve preset. Defaults to `'default'`. Use `'none'` to disable
+  /// animation (matches SwiftUI's `nil` animation argument).
+  type?: AnimationCurve;
+  /// Override duration in seconds. Honored by curves that accept one
+  /// (`easeIn`, `easeOut`, `easeInOut`, `linear`). Ignored by `spring`.
+  duration?: number;
+  /// Stable hashable key. SwiftUI animates implicit changes whenever this
+  /// value differs from the previous render. Pass the same value across
+  /// renders to keep the animation idle; bump it (or pass the changing
+  /// value itself) when an animation should fire.
+  value?: string | number | boolean;
+}
+
+/// SwiftUI `.animation(_:value:)`. Wraps any view; subsequent prop or
+/// child changes that happen on the same commit as a `value` change
+/// animate with the chosen curve.
+///
+/// ```tsx
+/// <ProgressView
+///   value={pct}
+///   modifiers={[animation({ type: 'easeIn', value: pct })]}
+/// />
+/// ```
+export function animation(params: AnimationParams = {}) {
+  return createModifier('animation', params);
+}

package/src/modifiers/antialiased.ts

@@ -0,0 +1,7 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `.antialiased(_:)`. Image-only — smooths edges when the
+/// image is drawn rotated, scaled, or otherwise off-pixel-grid.
+export function antialiased(value: boolean = true) {
+  return createModifier('antialiased', { value });
+}

package/src/modifiers/aspectRatio.ts

@@ -0,0 +1,19 @@
+import { createModifier } from './createModifier';
+
+export interface AspectRatioParams {
+  /// Width / height ratio. When omitted, the view's intrinsic ratio is
+  /// preserved (only `contentMode` is enforced).
+  ratio?: number;
+  /// `'fit'` shrinks the view to fit the available space without
+  /// cropping; `'fill'` expands to fill, cropping overflow. Default
+  /// is `'fit'`.
+  contentMode?: 'fit' | 'fill';
+}
+
+/// SwiftUI `.aspectRatio(_:contentMode:)`. Generic — works on any view.
+export function aspectRatio(params?: AspectRatioParams | number) {
+  if (typeof params === 'number') {
+    return createModifier('aspectRatio', { ratio: params });
+  }
+  return createModifier('aspectRatio', params);
+}

package/src/modifiers/autocorrectionDisabled.ts

@@ -0,0 +1,26 @@
+import { createModifier } from './createModifier';
+
+export interface AutocorrectionDisabledParams {
+  /// Whether autocorrection is disabled. Defaults to `true`.
+  value?: boolean;
+}
+
+/// SwiftUI `.autocorrectionDisabled(_:)`. Disables (or re-enables)
+/// autocorrection for text entry in this view. Pass a boolean directly or an
+/// object; omitting the value defaults to `true` (i.e. disabled).
+export function autocorrectionDisabled(
+  value?: boolean
+): ReturnType<typeof createModifier>;
+export function autocorrectionDisabled(
+  params: AutocorrectionDisabledParams
+): ReturnType<typeof createModifier>;
+export function autocorrectionDisabled(
+  arg?: boolean | AutocorrectionDisabledParams
+) {
+  if (typeof arg === 'object') {
+    return createModifier('autocorrectionDisabled', {
+      value: arg.value ?? true,
+    });
+  }
+  return createModifier('autocorrectionDisabled', { value: arg ?? true });
+}

package/src/modifiers/background.ts

@@ -0,0 +1,37 @@
+import type { ReactNode } from 'react';
+
+import { createModifier } from './createModifier';
+
+export type BackgroundAlignment =
+  | 'center'
+  | 'leading'
+  | 'trailing'
+  | 'top'
+  | 'bottom'
+  | 'topLeading'
+  | 'topTrailing'
+  | 'bottomLeading'
+  | 'bottomTrailing';
+
+export interface BackgroundContentParams {
+  /// View(s) drawn behind the modified view. Hoisted across the bridge as
+  /// modifier content. Maps to SwiftUI `.background(alignment:content:)`.
+  content: ReactNode;
+  /// How the background is aligned within the view's bounds. Defaults to
+  /// `'center'`, matching SwiftUI.
+  alignment?: BackgroundAlignment;
+}
+
+/// SwiftUI `.background(_:)` with a flat color. The color string supports
+/// named colors (`'red'`, `'blue'`, …), SwiftUI semantic colors
+/// (`'primary'`, `'secondary'`, `'accent'`), and `#RRGGBB` / `#RRGGBBAA`.
+export function background(color: string): ReturnType<typeof createModifier>;
+/// SwiftUI `.background(alignment:content:)` with arbitrary view content
+/// drawn behind the modified view.
+export function background(
+  params: BackgroundContentParams
+): ReturnType<typeof createModifier>;
+export function background(arg: string | BackgroundContentParams) {
+  if (typeof arg === 'string') return createModifier('background', { color: arg });
+  return createModifier('background', arg);
+}

package/src/modifiers/backgroundExtensionEffect.ts

@@ -0,0 +1,9 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `.backgroundExtensionEffect()` (watchOS 26 "Liquid Glass").
+/// Extends the view's content beneath adjacent Liquid Glass surfaces by
+/// mirroring/blurring it, so the glass picks up the underlying color.
+/// Takes no parameters. No-op on watchOS < 26.
+export function backgroundExtensionEffect() {
+  return createModifier('backgroundExtensionEffect');
+}

package/src/modifiers/backgroundStyle.ts

@@ -0,0 +1,10 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `.backgroundStyle(_:)` (watchOS 9+). Sets the default style for
+/// the backgrounds of views within this view. The `style` string supports
+/// named / `#RRGGBB` / `#RRGGBBAA` colors, SwiftUI semantic colors,
+/// hierarchical levels, `'tint'`, and (watchOS 10+) materials — resolved by
+/// the shared shape-style parser.
+export function backgroundStyle(style: string) {
+  return createModifier('backgroundStyle', { style });
+}

package/src/modifiers/baselineOffset.ts

@@ -0,0 +1,8 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `.baselineOffset(_:)`. Shifts text vertically relative to its
+/// baseline, in points. Positive values raise the text; negative values
+/// lower it.
+export function baselineOffset(value: number) {
+  return createModifier('baselineOffset', { value });
+}

package/src/modifiers/blendMode.ts

@@ -0,0 +1,29 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `BlendMode` cases. Mirrors the porter-duff / separable blend
+/// modes available to `.blendMode(_:)`.
+export type BlendModeValue =
+  | 'normal'
+  | 'multiply'
+  | 'screen'
+  | 'overlay'
+  | 'darken'
+  | 'lighten'
+  | 'colorDodge'
+  | 'colorBurn'
+  | 'softLight'
+  | 'hardLight'
+  | 'difference'
+  | 'exclusion'
+  | 'hue'
+  | 'saturation'
+  | 'color'
+  | 'luminosity'
+  | 'plusDarker'
+  | 'plusLighter';
+
+/// SwiftUI `.blendMode(_:)`. Sets how the view composites with the
+/// content behind it.
+export function blendMode(mode: BlendModeValue) {
+  return createModifier('blendMode', { mode });
+}

package/src/modifiers/blur.ts

@@ -0,0 +1,17 @@
+import { createModifier } from './createModifier';
+
+export interface BlurParams {
+  /// Gaussian blur radius in points. Larger values blur more.
+  radius: number;
+  /// When `true`, the blur is opaque (fully obscures content behind the
+  /// view's bounds); when `false` (default) the blur is transparent.
+  opaque?: boolean;
+}
+
+/// SwiftUI `.blur(radius:opaque:)`. Applies a Gaussian blur to the view.
+export function blur(params: BlurParams): ReturnType<typeof createModifier>;
+export function blur(radius: number): ReturnType<typeof createModifier>;
+export function blur(a: BlurParams | number) {
+  if (typeof a === 'number') return createModifier('blur', { radius: a });
+  return createModifier('blur', { opaque: false, ...a });
+}

package/src/modifiers/bold.ts

@@ -0,0 +1,15 @@
+import { createModifier } from './createModifier';
+
+export interface BoldParams {
+  /// Whether bold is active. Defaults to `true`.
+  value?: boolean;
+}
+
+/// SwiftUI `.bold(_:)`. Applies a bold font weight to text within the
+/// view. Pass `false` to explicitly turn it off.
+export function bold(params?: BoldParams | boolean) {
+  if (typeof params === 'boolean') {
+    return createModifier('bold', { value: params });
+  }
+  return createModifier('bold', params);
+}

package/src/modifiers/border.ts

@@ -0,0 +1,21 @@
+import { createModifier } from './createModifier';
+
+export interface BorderParams {
+  /// Border color. Named (`'red'`), semantic (`'primary'`, `'accent'`), or
+  /// `#RRGGBB` / `#RRGGBBAA`.
+  color: string;
+  /// Border width in points. Defaults to `1`, matching SwiftUI.
+  width?: number;
+}
+
+/// SwiftUI `.border(_:width:)`. Draws a border of the given color and width
+/// around the view's frame edges.
+export function border(params: BorderParams): ReturnType<typeof createModifier>;
+export function border(
+  color: string,
+  width?: number
+): ReturnType<typeof createModifier>;
+export function border(a: BorderParams | string, b?: number) {
+  if (typeof a === 'string') return createModifier('border', { color: a, width: b });
+  return createModifier('border', a);
+}

package/src/modifiers/brightness.ts

@@ -0,0 +1,7 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `.brightness(_:)`. Brightens (positive) or darkens (negative)
+/// the view by adding `value` to each color component. `0` is unchanged.
+export function brightness(value: number) {
+  return createModifier('brightness', { value });
+}

package/src/modifiers/buttonBorderShape.ts

@@ -0,0 +1,16 @@
+import { createModifier } from './createModifier';
+
+/// Border shapes a button can adopt via `.buttonBorderShape(_:)`.
+/// - `'circle'` requires watchOS 10+; on older systems it falls back to the
+///   system default (`'automatic'`).
+export type ButtonBorderShapeValue =
+  | 'automatic'
+  | 'capsule'
+  | 'roundedRectangle'
+  | 'circle';
+
+/// SwiftUI `.buttonBorderShape(_:)`. Sets the shape used to draw a button's
+/// border (most visible with bordered button styles).
+export function buttonBorderShape(shape: ButtonBorderShapeValue = 'automatic') {
+  return createModifier('buttonBorderShape', { shape });
+}

package/src/modifiers/buttonRepeatBehavior.ts

@@ -0,0 +1,15 @@
+import { createModifier } from './createModifier';
+
+/// Whether buttons repeatedly trigger their action on a press-and-hold.
+export type ButtonRepeatBehaviorValue = 'automatic' | 'enabled' | 'disabled';
+
+/// SwiftUI `.buttonRepeatBehavior(_:)`. Controls whether descendant buttons
+/// fire their action repeatedly while held down.
+///
+/// Requires watchOS 10+. On earlier systems this is a no-op (the view is
+/// returned unchanged).
+export function buttonRepeatBehavior(
+  behavior: ButtonRepeatBehaviorValue = 'automatic'
+) {
+  return createModifier('buttonRepeatBehavior', { behavior });
+}

package/src/modifiers/buttonSizing.ts

@@ -0,0 +1,17 @@
+import { createModifier } from './createModifier';
+
+/// How a button sizes itself within its container.
+/// - `'fitted'` hugs the title
+/// - `'flexible'` expands to fill the available width
+export type ButtonSizingValue = 'automatic' | 'fitted' | 'flexible';
+
+/// SwiftUI `.buttonSizing(_:)`.
+///
+/// LIMITATION: `.buttonSizing(_:)` only exists on watchOS 26+ SDKs, which is
+/// newer than this package's build floor. To keep the native side compiling on
+/// every supported SDK, the modifier is currently a documented no-op — the view
+/// is returned unchanged. The factory still ships so callers can adopt it
+/// without churn once the native side raises its SDK and wires it up.
+export function buttonSizing(sizing: ButtonSizingValue = 'automatic') {
+  return createModifier('buttonSizing', { sizing });
+}

package/src/modifiers/buttonStyle.ts

@@ -0,0 +1,14 @@
+import { createModifier } from './createModifier';
+
+export type ButtonStyle =
+  | 'automatic'
+  | 'bordered'
+  | 'borderedProminent'
+  | 'borderless'
+  | 'plain';
+
+/// SwiftUI `.buttonStyle(_:)`. Sets the visual style applied to `Button`s
+/// within the view. `'automatic'` defers to the platform default.
+export function buttonStyle(style: ButtonStyle = 'automatic') {
+  return createModifier('buttonStyle', { style });
+}

package/src/modifiers/clipShape.ts

@@ -0,0 +1,24 @@
+import { createModifier } from './createModifier';
+
+export type ClipShapeKind =
+  | 'rectangle'
+  | 'circle'
+  | 'capsule'
+  | 'ellipse'
+  | 'roundedRectangle';
+
+export interface ClipShapeParams {
+  /// Which shape to clip to. Defaults to `'rectangle'`.
+  shape?: ClipShapeKind;
+  /// Corner radius used only when `shape` is `'roundedRectangle'`.
+  cornerRadius?: number;
+}
+
+/// SwiftUI `.clipShape(_:)`. Clips the view to the given shape. For
+/// `'roundedRectangle'` pass `cornerRadius` to control the corner curvature.
+export function clipShape(
+  params?: ClipShapeParams | ClipShapeKind
+): ReturnType<typeof createModifier> {
+  if (typeof params === 'string') return createModifier('clipShape', { shape: params });
+  return createModifier('clipShape', params);
+}

package/src/modifiers/clipped.ts

@@ -0,0 +1,7 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `.clipped()`. Clips the view to its bounding frame, hiding any
+/// content that extends beyond it.
+export function clipped() {
+  return createModifier('clipped');
+}

package/src/modifiers/colorInvert.ts

@@ -0,0 +1,6 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `.colorInvert()`. Inverts every color in the view.
+export function colorInvert() {
+  return createModifier('colorInvert');
+}

package/src/modifiers/colorMultiply.ts

@@ -0,0 +1,9 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `.colorMultiply(_:)`. Multiplies the view's colors by the
+/// given color (a cheap tint). The color string supports named colors
+/// (`'red'`, …), SwiftUI semantic colors (`'primary'`, `'accent'`), and
+/// `#RRGGBB` / `#RRGGBBAA`.
+export function colorMultiply(color: string) {
+  return createModifier('colorMultiply', { color });
+}

package/src/modifiers/colorScheme.ts

@@ -0,0 +1,10 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `ColorScheme` values.
+export type ColorScheme = 'light' | 'dark';
+
+/// SwiftUI `.colorScheme(_:)`. Forces this view's subtree to render with the
+/// given color scheme, overriding the system appearance.
+export function colorScheme(value: ColorScheme) {
+  return createModifier('colorScheme', { value });
+}

package/src/modifiers/componentStyles.ts

@@ -0,0 +1,19 @@
+// "Component styles" modifiers — map a string to a SwiftUI component style.
+export { buttonStyle, type ButtonStyle } from './buttonStyle';
+export { toggleStyle, type ToggleStyle } from './toggleStyle';
+export { pickerStyle, type PickerStyle } from './pickerStyle';
+export { datePickerStyle, type DatePickerStyle } from './datePickerStyle';
+export {
+  progressViewStyle,
+  type ProgressViewStyle,
+} from './progressViewStyle';
+export { gaugeStyle, type GaugeStyle } from './gaugeStyle';
+export { textFieldStyle, type TextFieldStyle } from './textFieldStyle';
+export { labelStyle, type LabelStyle } from './labelStyle';
+export {
+  labeledContentStyle,
+  type LabeledContentStyle,
+} from './labeledContentStyle';
+export { formStyle, type FormStyle } from './formStyle';
+export { tabViewStyle, type TabViewStyle } from './tabViewStyle';
+export { controlSize, type ControlSize } from './controlSize';

package/src/modifiers/compositingGroup.ts

@@ -0,0 +1,8 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `.compositingGroup()`. Composites the view's descendants as a
+/// single layer before applying effects like opacity or blend modes, so
+/// they apply to the group as a whole rather than each child.
+export function compositingGroup() {
+  return createModifier('compositingGroup');
+}

package/src/modifiers/confirmationDialog.ts

@@ -0,0 +1,38 @@
+import type { ReactNode } from 'react';
+import { createModifier } from './createModifier';
+
+/// Controls whether the dialog's title is shown above the actions.
+export type TitleVisibility = 'automatic' | 'visible' | 'hidden';
+
+export interface ConfirmationDialogParams {
+  /// The dialog's title text.
+  title: string;
+  /// Whether the dialog is shown. JS owns the source of truth; the native
+  /// side mirrors it in local `@State` and converges on the JS value.
+  isPresented: boolean;
+  /// Fired with the new boolean whenever the presentation state changes.
+  onChange?: (isPresented: boolean) => void;
+  /// The dialog's action buttons (typically `<Button>`s).
+  actions: ReactNode;
+  /// Optional descriptive message shown above the actions.
+  message?: ReactNode;
+  /// Whether to show the title. Defaults to `'automatic'`.
+  titleVisibility?: TitleVisibility;
+}
+
+/// SwiftUI `.confirmationDialog(_:isPresented:titleVisibility:actions:message:)`.
+/// Presents an action-sheet-style dialog titled `title` when `isPresented`
+/// is true. The boolean is bound two-way so a button tap / dismissal
+/// reports back to JS via `onChange`.
+export function confirmationDialog(params: ConfirmationDialogParams) {
+  const { title, isPresented, onChange, actions, message, titleVisibility } =
+    params;
+  return createModifier('confirmationDialog', {
+    title,
+    isPresented,
+    handler: onChange,
+    actions,
+    message,
+    titleVisibility,
+  });
+}