@appsent-co/react-native-watchos 0.1.0

package/src/modifiers/searchable.ts

@@ -0,0 +1,25 @@
+import { createModifier } from './createModifier';
+
+export interface SearchableParams {
+  /// Current search query. JS owns the source of truth; the native side
+  /// mirrors it in local `@State` so typing feels instant.
+  text: string;
+  /// Fired with the new query string on every edit.
+  onChange: (text: string) => void;
+  /// Optional placeholder shown in the empty search field.
+  prompt?: string;
+}
+
+/// SwiftUI `.searchable(text:prompt:)`. Intended to add a search field to a
+/// view inside a `<NavigationStack>`, binding `text` two-way and firing
+/// `onChange` with each new query.
+///
+/// LIMITATION: `.searchable` is `@available(watchOS, unavailable)` in
+/// SwiftUI — there is no search-field affordance on watchOS — so the native
+/// applier is a no-op (the view renders unchanged and `onChange` never
+/// fires). This factory is kept so callers can express intent and so it can
+/// be upgraded in place if a future watchOS adds the API.
+export function searchable(params: SearchableParams) {
+  const { text, onChange, prompt } = params;
+  return createModifier('searchable', { text, handler: onChange, prompt });
+}

package/src/modifiers/selectionDisabled.ts

@@ -0,0 +1,7 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `.selectionDisabled(_:)` (watchOS 10+). Prevents the affected
+/// view (e.g. a `List` row) from being selected. No-op on watchOS 9.
+export function selectionDisabled(value: boolean = true) {
+  return createModifier('selectionDisabled', { value });
+}

package/src/modifiers/sensoryFeedback.ts

@@ -0,0 +1,32 @@
+import { createModifier } from './createModifier';
+
+/// The haptic feedback pattern played when the trigger changes. Maps to
+/// `SensoryFeedback` cases: `success` / `warning` / `error` (notification
+/// feedbacks), `selection`, and `impact`.
+export type SensoryFeedbackKind =
+  | 'success'
+  | 'warning'
+  | 'error'
+  | 'selection'
+  | 'impact';
+
+export interface SensoryFeedbackParams {
+  /// Which haptic pattern to play.
+  feedback: SensoryFeedbackKind;
+  /// Equatable trigger. Feedback plays whenever this value changes between
+  /// renders — pass a counter you bump, or the changing value itself. Strings
+  /// and numbers both survive the bridge.
+  trigger: string | number;
+}
+
+/// SwiftUI `.sensoryFeedback(_:trigger:)` — plays haptic feedback when
+/// `trigger` changes. Requires watchOS 10; on older systems the view is
+/// returned unchanged.
+///
+/// Implemented natively via a `ViewModifier` that holds the last-seen trigger
+/// and replays the feedback on change. The trigger is coerced to a single
+/// hashable key, so exact type parity across renders isn't required — only
+/// that the same input maps to the same key.
+export function sensoryFeedback(params: SensoryFeedbackParams) {
+  return createModifier('sensoryFeedback', params);
+}

package/src/modifiers/shadow.ts

@@ -0,0 +1,18 @@
+import { createModifier } from './createModifier';
+
+export interface ShadowParams {
+  /// Shadow color. Named, semantic, or `#RRGGBB` / `#RRGGBBAA`. When
+  /// omitted, SwiftUI uses its default translucent black shadow.
+  color?: string;
+  /// Blur radius of the shadow. Defaults to `0`.
+  radius?: number;
+  /// Horizontal offset. Defaults to `0`.
+  x?: number;
+  /// Vertical offset. Defaults to `0`.
+  y?: number;
+}
+
+/// SwiftUI `.shadow(color:radius:x:y:)`. Draws a drop shadow behind the view.
+export function shadow(params: ShadowParams = {}) {
+  return createModifier('shadow', params);
+}

package/src/modifiers/sheet.ts

@@ -0,0 +1,22 @@
+import type { ReactNode } from 'react';
+import { createModifier } from './createModifier';
+
+export interface SheetParams {
+  /// Whether the sheet is shown. JS owns the source of truth; the native
+  /// side mirrors it in local `@State` so the presentation is responsive
+  /// and converges on the JS value.
+  isPresented: boolean;
+  /// Fired with the new boolean whenever the presentation state changes
+  /// (shown on the modeled binding, or `false` on interactive dismiss).
+  onChange?: (isPresented: boolean) => void;
+  /// The sheet's content.
+  content: ReactNode;
+}
+
+/// SwiftUI `.sheet(isPresented:onDismiss:content:)`. Presents `content`
+/// modally when `isPresented` is true. The boolean is bound two-way so
+/// an interactive (swipe-down) dismiss reports back to JS via `onChange`.
+export function sheet(params: SheetParams) {
+  const { isPresented, onChange, content } = params;
+  return createModifier('sheet', { isPresented, handler: onChange, content });
+}

package/src/modifiers/simultaneousGesture.ts

@@ -0,0 +1,15 @@
+import { createModifier } from './createModifier';
+import type { GestureParams } from './gesture';
+
+/// SwiftUI `.simultaneousGesture(_:)`. Attaches a gesture that recognizes
+/// alongside the view's own (and any ancestor/descendant) gestures rather
+/// than competing with them.
+///
+/// **Limited (v1):** same bridging constraints as `gesture` — only `'tap'`
+/// and `'longPress'` are supported; arbitrary SwiftUI `Gesture` values are
+/// not expressible across the bridge.
+export function simultaneousGesture(params: GestureParams) {
+  return createModifier('simultaneousGesture', params);
+}
+
+export type { GestureParams, GestureType } from './gesture';

package/src/modifiers/springLoadingBehavior.ts

@@ -0,0 +1,13 @@
+import { createModifier } from './createModifier';
+
+export type SpringLoadingBehaviorValue = 'automatic' | 'enabled' | 'disabled';
+
+/// SwiftUI `.springLoadingBehavior(_:)` (watchOS 10+). Controls whether a
+/// control activates ("spring-loads") when the user hovers a dragged item
+/// over it. `'automatic'` defers to the system default. On watchOS 9 the
+/// modifier is a no-op (the API is unavailable).
+export function springLoadingBehavior(
+  value: SpringLoadingBehaviorValue = 'automatic'
+) {
+  return createModifier('springLoadingBehavior', { value });
+}

package/src/modifiers/strikethrough.ts

@@ -0,0 +1,19 @@
+import { createModifier } from './createModifier';
+
+export interface StrikethroughParams {
+  /// Whether the strikethrough is active. Defaults to `true`.
+  value?: boolean;
+  /// Strikethrough color. Accepts a named color or hex (`'#RRGGBB'` /
+  /// `'#RRGGBBAA'`). Omit to use the text's foreground color.
+  color?: string;
+}
+
+/// SwiftUI `.strikethrough(_:color:)`. Applies a strikethrough to text
+/// within the view. Pass a boolean to toggle it, or an object to also set
+/// a color.
+export function strikethrough(params?: StrikethroughParams | boolean) {
+  if (typeof params === 'boolean') {
+    return createModifier('strikethrough', { value: params });
+  }
+  return createModifier('strikethrough', params);
+}

package/src/modifiers/styling.ts

@@ -0,0 +1,22 @@
+// "Styling" modifiers. `background` is intentionally NOT re-exported here —
+// it ships from `src/index.ts` directly (its content overload lives in
+// `./background`).
+export { foregroundStyle } from './foregroundStyle';
+export { backgroundStyle } from './backgroundStyle';
+export { border, type BorderParams } from './border';
+export {
+  clipShape,
+  type ClipShapeParams,
+  type ClipShapeKind,
+} from './clipShape';
+export { clipped } from './clipped';
+export { cornerRadius, type CornerRadiusParams } from './cornerRadius';
+export { opacity, type OpacityParams } from './opacity';
+export { shadow, type ShadowParams } from './shadow';
+export { tint } from './tint';
+export {
+  overlay,
+  type OverlayParams,
+  type OverlayAlignment,
+} from './overlay';
+export { mask, type MaskParams, type MaskAlignment } from './mask';

package/src/modifiers/submitLabel.ts

@@ -0,0 +1,32 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `SubmitLabel` values — the keyboard's return-key label.
+export type SubmitLabelKind =
+  | 'done'
+  | 'go'
+  | 'send'
+  | 'join'
+  | 'route'
+  | 'search'
+  | 'return'
+  | 'next'
+  | 'continue';
+
+export interface SubmitLabelParams {
+  label: SubmitLabelKind;
+}
+
+/// SwiftUI `.submitLabel(_:)`. Sets the semantic label shown on the keyboard's
+/// submit key. Pass a label string directly or an object.
+export function submitLabel(
+  label: SubmitLabelKind
+): ReturnType<typeof createModifier>;
+export function submitLabel(
+  params: SubmitLabelParams
+): ReturnType<typeof createModifier>;
+export function submitLabel(arg: SubmitLabelKind | SubmitLabelParams) {
+  if (typeof arg === 'string') {
+    return createModifier('submitLabel', { label: arg });
+  }
+  return createModifier('submitLabel', arg);
+}

package/src/modifiers/swipeActions.ts

@@ -0,0 +1,36 @@
+import type { ReactNode } from 'react';
+
+import { createModifier } from './createModifier';
+
+export type SwipeEdge = 'leading' | 'trailing';
+
+export interface SwipeActionsParams {
+  /// Which edge the actions are revealed from. Defaults to `'trailing'`.
+  edge?: SwipeEdge;
+  /// Whether a full swipe triggers the first action. Defaults to true.
+  allowsFullSwipe?: boolean;
+  /// The swipe action buttons. Hoisted into a content slot by `useModifiers`.
+  content: ReactNode;
+}
+
+/// SwiftUI `.swipeActions(edge:allowsFullSwipe:) { … }`. Attaches swipe
+/// actions to a list row; `content` holds the action `Button`s.
+///
+/// ```tsx
+/// <Text modifiers={[swipeActions({ content: <Button title="Delete" .../> })]} />
+/// ```
+export function swipeActions(content: ReactNode): ReturnType<typeof createModifier>;
+export function swipeActions(
+  params: SwipeActionsParams
+): ReturnType<typeof createModifier>;
+export function swipeActions(a: SwipeActionsParams | ReactNode) {
+  if (a != null && typeof a === 'object' && 'content' in a) {
+    const p = a as SwipeActionsParams;
+    return createModifier('swipeActions', {
+      edge: p.edge,
+      allowsFullSwipe: p.allowsFullSwipe,
+      content: p.content,
+    });
+  }
+  return createModifier('swipeActions', { content: a as ReactNode });
+}

package/src/modifiers/symbolEffect.ts

@@ -0,0 +1,20 @@
+import { createModifier } from './createModifier';
+
+export type SymbolEffectType =
+  | 'bounce'
+  | 'pulse'
+  | 'variableColor'
+  | 'scale'
+  | 'appear'
+  | 'disappear'
+  | 'wiggle'
+  | 'breathe'
+  | 'rotate';
+
+/// SwiftUI `.symbolEffect(_:)`. Applies an animated SF Symbol effect
+/// (`SymbolEffect`). Requires watchOS 10+; `'wiggle'`, `'breathe'` and
+/// `'rotate'` require watchOS 11+. On older systems the modifier is a
+/// no-op (the view renders unchanged).
+export function symbolEffect(effect: SymbolEffectType) {
+  return createModifier('symbolEffect', { effect });
+}

package/src/modifiers/symbolRenderingMode.ts

@@ -0,0 +1,13 @@
+import { createModifier } from './createModifier';
+
+export type SymbolRenderingMode =
+  | 'monochrome'
+  | 'hierarchical'
+  | 'palette'
+  | 'multicolor';
+
+/// SwiftUI `.symbolRenderingMode(_:)`. Picks the colour-rendering strategy
+/// for SF Symbols inside the view (`SymbolRenderingMode`).
+export function symbolRenderingMode(mode: SymbolRenderingMode) {
+  return createModifier('symbolRenderingMode', { mode });
+}

package/src/modifiers/symbolVariant.ts

@@ -0,0 +1,15 @@
+import { createModifier } from './createModifier';
+
+export type SymbolVariant =
+  | 'none'
+  | 'circle'
+  | 'square'
+  | 'rectangle'
+  | 'fill'
+  | 'slash';
+
+/// SwiftUI `.symbolVariant(_:)`. Substitutes a stylistic variant for SF
+/// Symbols inside the view (`SymbolVariants`).
+export function symbolVariant(variant: SymbolVariant) {
+  return createModifier('symbolVariant', { variant });
+}

package/src/modifiers/tabItem.ts

@@ -0,0 +1,19 @@
+import type { ReactNode } from 'react';
+import { createModifier } from './createModifier';
+
+export interface TabItemParams {
+  /// The tab's label — typically a `Label` or `Text`/`Image` — shown in the
+  /// `TabView`'s tab bar.
+  content: ReactNode;
+}
+
+/// SwiftUI `.tabItem { … }` (watchOS 7+). Sets the label for a view used as a
+/// page inside a `TabView`.
+export function tabItem(content: ReactNode): ReturnType<typeof createModifier>;
+export function tabItem(params: TabItemParams): ReturnType<typeof createModifier>;
+export function tabItem(a: TabItemParams | ReactNode) {
+  if (a && typeof a === 'object' && 'content' in a) {
+    return createModifier('tabItem', a as TabItemParams);
+  }
+  return createModifier('tabItem', { content: a as ReactNode });
+}

package/src/modifiers/tabViewStyle.ts

@@ -0,0 +1,14 @@
+import { createModifier } from './createModifier';
+
+export type TabViewStyle =
+  | 'automatic'
+  | 'page'
+  | 'verticalPage'
+  | 'carousel';
+
+/// SwiftUI `.tabViewStyle(_:)`. Sets the visual style applied to `TabView`s
+/// within the view. `'automatic'` defers to the platform default;
+/// `'verticalPage'` and `'carousel'` are watchOS-specific styles.
+export function tabViewStyle(style: TabViewStyle = 'automatic') {
+  return createModifier('tabViewStyle', { style });
+}

package/src/modifiers/tag.ts

@@ -0,0 +1,7 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `.tag(_:)`. Tags the view with a value used by selection-driven
+/// containers like `Picker` and `TabView` to match the bound selection.
+export function tag(value: string) {
+  return createModifier('tag', { value });
+}

package/src/modifiers/task.ts

@@ -0,0 +1,12 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `.task(priority:_:)`. Fires `handler` once when the view appears
+/// (the bridged async task simply invokes the JS callback). Use it for
+/// load-on-appear side effects.
+///
+/// ```tsx
+/// <Text modifiers={[task(() => load())]} />
+/// ```
+export function task(handler: () => void) {
+  return createModifier('task', { handler });
+}

package/src/modifiers/text.ts

@@ -0,0 +1,31 @@
+// "Text" modifiers. `font` is NOT re-exported here — it already ships
+// from `src/index.ts`. One unit owns this file.
+export {
+  fontDesign,
+  type FontDesign,
+  type FontDesignParams,
+} from './fontDesign';
+export { fontWeight, type FontWeightParams } from './fontWeight';
+export { bold, type BoldParams } from './bold';
+export { italic, type ItalicParams } from './italic';
+export { underline, type UnderlineParams } from './underline';
+export { strikethrough, type StrikethroughParams } from './strikethrough';
+export { lineLimit, type LineLimitParams } from './lineLimit';
+export { lineSpacing, type LineSpacingParams } from './lineSpacing';
+export {
+  multilineTextAlignment,
+  type TextAlignment,
+  type MultilineTextAlignmentParams,
+} from './multilineTextAlignment';
+export {
+  minimumScaleFactor,
+  type MinimumScaleFactorParams,
+} from './minimumScaleFactor';
+export {
+  truncationMode,
+  type TruncationMode,
+  type TruncationModeParams,
+} from './truncationMode';
+export { monospaced, type MonospacedParams } from './monospaced';
+export { monospacedDigit } from './monospacedDigit';
+export { textCase, type TextCase, type TextCaseParams } from './textCase';

package/src/modifiers/textCase.ts

@@ -0,0 +1,19 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `Text.Case` values. `null` clears any inherited case
+/// transform (SwiftUI's `nil`).
+export type TextCase = 'uppercase' | 'lowercase';
+
+export interface TextCaseParams {
+  value?: TextCase | null;
+}
+
+/// SwiftUI `.textCase(_:)`. Applies a case transform to text within the
+/// view. Pass `'uppercase'`/`'lowercase'`, `null` to clear it, or an
+/// object.
+export function textCase(params?: TextCaseParams | TextCase | null) {
+  if (typeof params === 'string' || params === null) {
+    return createModifier('textCase', { value: params });
+  }
+  return createModifier('textCase', params);
+}

package/src/modifiers/textContentType.ts

@@ -0,0 +1,36 @@
+import { createModifier } from './createModifier';
+
+/// Subset of `WKTextContentType` (watchOS's content-type hints) that maps
+/// cleanly across platforms. watchOS does not expose the full
+/// `UITextContentType` surface, so this is intentionally limited to the
+/// common, broadly-available cases.
+export type TextContentTypeKind =
+  | 'username'
+  | 'password'
+  | 'newPassword'
+  | 'oneTimeCode'
+  | 'emailAddress'
+  | 'telephoneNumber'
+  | 'name'
+  | 'URL';
+
+export interface TextContentTypeParams {
+  type: TextContentTypeKind;
+}
+
+/// SwiftUI `.textContentType(_:)`. On watchOS this takes a `WKTextContentType`,
+/// which hints the system about the semantic meaning of the field's text
+/// (autofill credentials, one-time codes, etc.). Pass a type string directly
+/// or an object.
+export function textContentType(
+  type: TextContentTypeKind
+): ReturnType<typeof createModifier>;
+export function textContentType(
+  params: TextContentTypeParams
+): ReturnType<typeof createModifier>;
+export function textContentType(arg: TextContentTypeKind | TextContentTypeParams) {
+  if (typeof arg === 'string') {
+    return createModifier('textContentType', { type: arg });
+  }
+  return createModifier('textContentType', arg);
+}

package/src/modifiers/textFieldStyle.ts

@@ -0,0 +1,10 @@
+import { createModifier } from './createModifier';
+
+export type TextFieldStyle = 'automatic' | 'plain' | 'roundedBorder';
+
+/// SwiftUI `.textFieldStyle(_:)`. Sets the visual style applied to
+/// `TextField`s within the view. `'automatic'` defers to the platform
+/// default.
+export function textFieldStyle(style: TextFieldStyle = 'automatic') {
+  return createModifier('textFieldStyle', { style });
+}

package/src/modifiers/textInputAutocapitalization.ts

@@ -0,0 +1,30 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `TextInputAutocapitalization` values.
+export type TextInputAutocapitalizationKind =
+  | 'never'
+  | 'words'
+  | 'sentences'
+  | 'characters';
+
+export interface TextInputAutocapitalizationParams {
+  value: TextInputAutocapitalizationKind;
+}
+
+/// SwiftUI `.textInputAutocapitalization(_:)` (watchOS 9+). Controls how text
+/// entry auto-capitalizes. Pass a value string directly or an object. No-ops
+/// on watchOS versions earlier than 9.
+export function textInputAutocapitalization(
+  value: TextInputAutocapitalizationKind
+): ReturnType<typeof createModifier>;
+export function textInputAutocapitalization(
+  params: TextInputAutocapitalizationParams
+): ReturnType<typeof createModifier>;
+export function textInputAutocapitalization(
+  arg: TextInputAutocapitalizationKind | TextInputAutocapitalizationParams
+) {
+  if (typeof arg === 'string') {
+    return createModifier('textInputAutocapitalization', { value: arg });
+  }
+  return createModifier('textInputAutocapitalization', arg);
+}

package/src/modifiers/textPolish.ts

@@ -0,0 +1,7 @@
+// "Text polish" modifiers — fine typographic adjustments applied at the
+// View level (watchOS 9+, except `textScale` which needs watchOS 11+).
+export { kerning } from './kerning';
+export { tracking } from './tracking';
+export { baselineOffset } from './baselineOffset';
+export { allowsTightening } from './allowsTightening';
+export { textScale, type TextScale } from './textScale';

package/src/modifiers/textScale.ts

@@ -0,0 +1,14 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `Text.Scale` values. `'default'` is the standard text size;
+/// `'secondary'` renders at a relatively smaller scale (e.g. for
+/// superscript-like emphasis).
+export type TextScale = 'default' | 'secondary';
+
+/// SwiftUI `.textScale(_:)`. Scales text relative to the inherited font.
+///
+/// Requires watchOS 11.0+. On earlier versions the native side leaves the
+/// view unchanged (no-op).
+export function textScale(value: TextScale = 'default') {
+  return createModifier('textScale', { value });
+}

package/src/modifiers/theme.ts

@@ -0,0 +1,8 @@
+// "Theme & sizing" modifiers.
+export { colorScheme, type ColorScheme } from './colorScheme';
+export { preferredColorScheme } from './preferredColorScheme';
+export { dynamicTypeSize, type DynamicTypeSize } from './dynamicTypeSize';
+export { redacted, type RedactionReason } from './redacted';
+export { unredacted } from './unredacted';
+export { privacySensitive } from './privacySensitive';
+export { headerProminence, type Prominence } from './headerProminence';

package/src/modifiers/tint.ts

@@ -0,0 +1,9 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `.tint(_:)`. Sets the tint color applied to controls and
+/// accessory content within the view. The color string supports named
+/// colors, SwiftUI semantic colors (`'primary'`, `'accent'`), and
+/// `#RRGGBB` / `#RRGGBBAA`.
+export function tint(color: string) {
+  return createModifier('tint', { color });
+}

package/src/modifiers/toggleStyle.ts

@@ -0,0 +1,9 @@
+import { createModifier } from './createModifier';
+
+export type ToggleStyle = 'automatic' | 'button' | 'switch';
+
+/// SwiftUI `.toggleStyle(_:)`. Sets the visual style applied to `Toggle`s
+/// within the view. `'automatic'` defers to the platform default.
+export function toggleStyle(style: ToggleStyle = 'automatic') {
+  return createModifier('toggleStyle', { style });
+}

package/src/modifiers/toolbar.ts

@@ -0,0 +1,27 @@
+// "Toolbar polish" modifiers.
+//
+// Not exported (unavailable on watchOS): `toolbarForegroundStyle` is iOS-only,
+// and `toolbarBackgroundVisibility` is watchOS 11+ — both omitted so JS never
+// exposes a factory the native side can't honor. See RNWToolbarModifiers.swift.
+export {
+  toolbarBackground,
+  type ToolbarBackgroundParams,
+  type ToolbarBars,
+} from './toolbarBackground';
+export {
+  toolbarColorScheme,
+  type ToolbarColorSchemeParams,
+  type ToolbarColorScheme,
+} from './toolbarColorScheme';
+export {
+  toolbarVisibility,
+  type ToolbarVisibilityParams,
+  type ToolbarVisibilityValue,
+} from './toolbarVisibility';
+export {
+  toolbarTitleDisplayMode,
+  type ToolbarTitleDisplayModeParams,
+  type ToolbarTitleDisplayModeValue,
+} from './toolbarTitleDisplayMode';
+export { toolbarTitleMenu, type ToolbarTitleMenuParams } from './toolbarTitleMenu';
+export { tabItem, type TabItemParams } from './tabItem';

package/src/modifiers/toolbarBackground.ts

@@ -0,0 +1,34 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `ToolbarPlacement` values usable as the `for:` argument of the
+/// toolbar modifiers. On watchOS only `automatic` and `navigationBar` are
+/// honored by the native side; other values degrade to `automatic`.
+export type ToolbarBars = 'automatic' | 'navigationBar';
+
+export interface ToolbarBackgroundParams {
+  /// Shape style for the bar background, resolved by `RNWShapeStyleParser`:
+  /// a named/hex color, a hierarchical level (`'primary'`…), `'tint'`, or a
+  /// watchOS-10+ material (`'thinMaterial'`…).
+  style: string;
+  /// Which bar(s) to affect. Defaults to `'automatic'`.
+  bars?: ToolbarBars;
+}
+
+/// SwiftUI `.toolbarBackground(_:for:)` (watchOS 10+). Sets the background
+/// shape style of the navigation bar. No-op on watchOS 9.
+export function toolbarBackground(
+  style: string,
+  bars?: ToolbarBars
+): ReturnType<typeof createModifier>;
+export function toolbarBackground(
+  params: ToolbarBackgroundParams
+): ReturnType<typeof createModifier>;
+export function toolbarBackground(
+  a: ToolbarBackgroundParams | string,
+  bars?: ToolbarBars
+) {
+  if (typeof a === 'string') {
+    return createModifier('toolbarBackground', { style: a, bars });
+  }
+  return createModifier('toolbarBackground', a);
+}

package/src/modifiers/toolbarColorScheme.ts

@@ -0,0 +1,32 @@
+import { createModifier } from './createModifier';
+import type { ToolbarBars } from './toolbarBackground';
+
+/// Toolbar color scheme. `null` (or omitted) restores the automatic scheme.
+export type ToolbarColorScheme = 'light' | 'dark' | null;
+
+export interface ToolbarColorSchemeParams {
+  /// `'light'`, `'dark'`, or `null`/undefined for automatic.
+  colorScheme?: ToolbarColorScheme;
+  /// Which bar(s) to affect. Defaults to `'automatic'`.
+  bars?: ToolbarBars;
+}
+
+/// SwiftUI `.toolbarColorScheme(_:for:)` (watchOS 10+). Forces a color scheme
+/// on the navigation bar. Passing `null` clears the override. No-op on
+/// watchOS 9.
+export function toolbarColorScheme(
+  colorScheme: ToolbarColorScheme,
+  bars?: ToolbarBars
+): ReturnType<typeof createModifier>;
+export function toolbarColorScheme(
+  params: ToolbarColorSchemeParams
+): ReturnType<typeof createModifier>;
+export function toolbarColorScheme(
+  a: ToolbarColorSchemeParams | ToolbarColorScheme,
+  bars?: ToolbarBars
+) {
+  if (a === null || typeof a === 'string') {
+    return createModifier('toolbarColorScheme', { colorScheme: a, bars });
+  }
+  return createModifier('toolbarColorScheme', a);
+}