@platform-blocks/ui 0.3.0 → 0.4.0

package/lib/components/Knob/hooks/useKnobInteraction.d.ts

@@ -0,0 +1,29 @@
+import { MutableRefObject } from 'react';
+import { View } from 'react-native';
+import type { LayoutState } from './useKnobGeometry';
+import type { NormalizedInteractionConfig } from '../interactionConfig';
+type UseKnobInteractionOptions = {
+    disabled: boolean;
+    readOnly: boolean;
+    pointerGestureEnabled: boolean;
+    hasSlideModes: boolean;
+    hasVerticalSlide: boolean;
+    hasHorizontalSlide: boolean;
+    canSpin: boolean;
+    interactionConfig: NormalizedInteractionConfig;
+    layoutState: LayoutState;
+    updateFromPoint: (x: number, y: number, final?: boolean, fromGrant?: boolean) => void;
+    onScrubStart?: () => void;
+    onScrubEnd?: () => void;
+    onChangeEnd?: (value: number) => void;
+    valueRef: MutableRefObject<number>;
+    hostRef: MutableRefObject<View | null>;
+    resetLastDragAngle: () => void;
+    handleValueUpdate: (value: number, final: boolean) => void;
+    degreesToValueDelta: (degrees: number) => number;
+    isRTL: boolean;
+};
+export declare const useKnobInteraction: ({ disabled, readOnly, pointerGestureEnabled, hasSlideModes, hasVerticalSlide, hasHorizontalSlide, canSpin, interactionConfig, layoutState, updateFromPoint, onScrubStart, onScrubEnd, onChangeEnd, valueRef, hostRef, resetLastDragAngle, handleValueUpdate, degreesToValueDelta, isRTL, }: UseKnobInteractionOptions) => {
+    panHandlers: import("react-native").GestureResponderHandlers;
+};
+export {};

package/lib/components/Knob/hooks/useKnobValue.d.ts

@@ -0,0 +1,31 @@
+import { MutableRefObject } from 'react';
+import type { SharedValue } from 'react-native-reanimated';
+import type { KnobMark, KnobVariant } from '../types';
+type UseKnobValueOptions = {
+    value?: number;
+    defaultValue: number;
+    min: number;
+    max: number;
+    step: number;
+    marks?: KnobMark[];
+    restrictToMarksProp?: boolean;
+    resolvedVariant: KnobVariant;
+    isEndless: boolean;
+    onChange?: (value: number) => void;
+    onChangeEnd?: (value: number) => void;
+    angle: SharedValue<number>;
+    valueToAngle: (value: number) => number;
+};
+export type UseKnobValueResult = {
+    marksNormalized: KnobMark[];
+    restrictToMarks: boolean;
+    displayValue: number;
+    resolvedValue: number;
+    valueRef: MutableRefObject<number>;
+    handleValueUpdate: (nextValue: number, final: boolean) => void;
+    isControlled: boolean;
+    normalizeValue: (value: number | undefined) => number;
+    clampValue: (value: number) => number;
+};
+export declare const useKnobValue: ({ value, defaultValue, min, max, step, marks, restrictToMarksProp, resolvedVariant, isEndless, onChange, onChangeEnd, angle, valueToAngle, }: UseKnobValueOptions) => UseKnobValueResult;
+export {};

package/lib/components/Knob/hooks/useKnobValueLabels.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import type { KnobMark, KnobProps, KnobValueLabelPosition } from '../types';
+export type ValueLabelSlots = Record<KnobValueLabelPosition, React.ReactNode | null>;
+type UseKnobValueLabelsOptions = {
+    resolvedVariant: KnobProps['variant'] | 'level' | 'status' | 'dual' | 'endless';
+    withLabel: boolean;
+    valueLabelProp: KnobProps['valueLabel'];
+    formatLabel?: KnobProps['formatLabel'];
+    panningValueFormatter?: (value: number) => React.ReactNode;
+    min: number;
+    max: number;
+    displayValue: number;
+    theme: any;
+    labelColor: string;
+    activeMark?: KnobMark | null;
+};
+export declare const useKnobValueLabels: ({ resolvedVariant, withLabel, valueLabelProp, formatLabel, panningValueFormatter, min, max, displayValue, theme, labelColor, activeMark, }: UseKnobValueLabelsOptions) => {
+    valueLabelSlots: ValueLabelSlots;
+};
+export {};

package/lib/components/Knob/index.d.ts

@@ -1,2 +1,2 @@
 export { Knob } from './Knob';
-export type { KnobProps, KnobMark } from './types';
+export type { KnobProps, KnobMark, KnobVariant, KnobValueLabelConfig, KnobValueLabelPosition, KnobRootProps, KnobFillPartProps, KnobRingPartProps, KnobProgressPartProps, KnobTickLayerPartProps, KnobPointerPartProps, KnobThumbPartProps, KnobValueLabelPartProps, } from './types';

package/lib/components/Knob/interactionConfig.d.ts

@@ -0,0 +1,22 @@
+import type { KnobInteractionConfig, KnobInteractionMode } from './types';
+export type NormalizedInteractionConfig = {
+    modes: KnobInteractionMode[];
+    lockThresholdPx: number;
+    variancePx: number;
+    slideDominanceRatio: number;
+    slideRatio: number;
+    slideHysteresisPx: number;
+    spinStopAtLimits: boolean;
+    spinDeadZoneDegrees: number;
+    spinPrecisionRadius?: number;
+    respectStartSide: boolean;
+    scroll: {
+        enabled: boolean;
+        ratio: number;
+        invert: boolean;
+        preventPageScroll: boolean;
+    };
+    onModeChange?: (mode: KnobInteractionMode | null) => void;
+};
+export declare const DEFAULT_INTERACTION_MODES: KnobInteractionMode[];
+export declare const normalizeInteractionConfig: (appearanceInteraction?: KnobInteractionConfig) => NormalizedInteractionConfig;

package/lib/components/Knob/styles.d.ts

@@ -0,0 +1,93 @@
+export declare const knobStyles: {
+    knob: {
+        position: "relative";
+        alignItems: "center";
+        justifyContent: "center";
+    };
+    container: {
+        position: "relative";
+        alignItems: "center";
+        justifyContent: "center";
+    };
+    thumb: {
+        position: "absolute";
+        left: "50%";
+        top: "50%";
+    };
+    fillLayer: {
+        position: "absolute";
+    };
+    ringBase: {
+        position: "absolute";
+    };
+    ringSvg: {
+        position: "absolute";
+    };
+    pointerLayer: {
+        position: "absolute";
+        left: number;
+        top: number;
+    };
+    markDot: {
+        position: "absolute";
+    };
+    markLabelContainer: {
+        position: "absolute";
+        alignItems: "center";
+        justifyContent: "center";
+        paddingHorizontal: number;
+    };
+    markLabelText: {
+        textAlign: "center";
+        includeFontPadding: false;
+    };
+    valueLabelContainer: {
+        flexDirection: "row";
+        alignItems: "center";
+        justifyContent: "center";
+        pointerEvents: "none";
+    };
+    valueLabelSecondaryContainer: {
+        opacity: number;
+    };
+    valueLabelText: {
+        textAlign: "center";
+    };
+    valueLabelSecondaryText: {
+        textAlign: "center";
+    };
+    valueLabelAffix: {
+        marginHorizontal: number;
+    };
+    valueLabelStackVertical: {
+        alignItems: "center";
+    };
+    valueLabelStackHorizontal: {
+        flexDirection: "row";
+        alignItems: "center";
+        justifyContent: "center";
+    };
+    tickDot: {
+        position: "absolute";
+    };
+    tickIcon: {
+        position: "absolute";
+    };
+    tickCustom: {
+        position: "absolute";
+    };
+    tickLabelContainer: {
+        position: "absolute";
+        alignItems: "center";
+        justifyContent: "center";
+        paddingHorizontal: number;
+    };
+    tickLabelText: {
+        textAlign: "center";
+        includeFontPadding: false;
+    };
+    statusIconContainer: {
+        alignItems: "center";
+        justifyContent: "center";
+    };
+};

package/lib/components/Knob/types.d.ts

@@ -1,4 +1,4 @@
-import type { ReactNode } from 'react';
+import type { FC, ReactNode } from 'react';
 import type { TextStyle, ViewStyle } from 'react-native';
 import type { SpacingProps, LayoutProps } from '../../core/utils';
 export interface KnobMark {
@@ -6,8 +6,194 @@ export interface KnobMark {
     value: number;
     /** Optional label rendered near the tick */
     label?: ReactNode;
+    /** Optional accent color applied when the mark becomes active */
+    accentColor?: string;
+    /** Optional icon surfaced by status-oriented variants */
+    icon?: ReactNode;
+}
+export type KnobVariant = 'level' | 'stepped' | 'endless' | 'dual' | 'status';
+export type KnobValueLabelPosition = 'center' | 'top' | 'bottom' | 'left' | 'right';
+export interface KnobValueLabelConfig {
+    /** Placement relative to the knob surface */
+    position?: KnobValueLabelPosition;
+    /** Primary formatter for the displayed value */
+    formatter?: (value: number) => ReactNode;
+    /** Optional prefix rendered before the value */
+    prefix?: ReactNode;
+    /** Optional suffix rendered after the value */
+    suffix?: ReactNode;
+    /** Style overrides for the wrapper */
+    containerStyle?: ViewStyle;
+    /** Style overrides for the primary text */
+    textStyle?: TextStyle;
+    /** Secondary readout rendered at an independent slot */
+    secondary?: {
+        formatter?: (value: number) => ReactNode;
+        position?: KnobValueLabelPosition;
+        prefix?: ReactNode;
+        suffix?: ReactNode;
+        containerStyle?: ViewStyle;
+        textStyle?: TextStyle;
+    };
+}
+export type KnobInteractionMode = 'spin' | 'vertical-slide' | 'horizontal-slide' | 'scroll';
+export interface KnobInteractionConfig {
+    /** Enabled gesture modalities */
+    modes?: KnobInteractionMode[];
+    /** Distance in pixels before committing to a gesture */
+    lockThresholdPx?: number;
+    /** Allowable perpendicular wiggle while detecting slides */
+    variancePx?: number;
+    /** Required dominance ratio (primary axis vs secondary) before locking into slide */
+    slideDominanceRatio?: number;
+    /** Pixels of movement required for one degree of rotation */
+    slideRatio?: number;
+    /** Minimum pixel delta before slides update, filters jitter */
+    slideHysteresisPx?: number;
+    /** Prevent spin gestures from wrapping past min/max in bounded mode */
+    spinStopAtLimits?: boolean;
+    /** Ignore tiny spin deltas (degrees) to avoid jitter */
+    spinDeadZoneDegrees?: number;
+    /** Radius at which spin drags increase precision */
+    spinPrecisionRadius?: number;
+    /** Whether to mirror GarageBand-style sidedness rules */
+    respectStartSide?: boolean;
+    /** Mouse/trackpad scroll behavior */
+    scroll?: {
+        enabled?: boolean;
+        ratio?: number;
+        invert?: boolean;
+        preventPageScroll?: boolean;
+    };
+    /** Gesture change callback */
+    onModeChange?: (mode: KnobInteractionMode | null) => void;
+}
+export interface KnobRingShadow {
+    color?: string;
+    offsetX?: number;
+    offsetY?: number;
+    blur?: number;
+    opacity?: number;
+}
+export interface KnobRingStyle {
+    thickness?: number;
+    color?: string;
+    trailColor?: string;
+    backgroundColor?: string;
+    cap?: 'butt' | 'round';
+    radiusOffset?: number;
+    shadow?: KnobRingShadow;
+}
+export interface KnobFillStyle {
+    color?: string;
+    borderWidth?: number;
+    borderColor?: string;
+    radiusOffset?: number;
+}
+export type KnobThumbShape = 'circle' | 'pill' | 'square';
+export interface KnobThumbGlow {
+    color?: string;
+    blur?: number;
+    intensity?: number;
+}
+export interface KnobThumbRenderContext {
+    value: number;
+    angle: number;
+    size: number;
+}
+export interface KnobThumbStyle {
+    size?: number;
+    shape?: KnobThumbShape;
+    color?: string;
+    strokeWidth?: number;
+    strokeColor?: string;
+    offset?: number;
+    glow?: KnobThumbGlow;
+    style?: ViewStyle;
+    renderThumb?: (context: KnobThumbRenderContext) => ReactNode;
+}
+export type KnobTickSource = 'marks' | 'steps' | 'values';
+export type KnobTickShape = 'dot' | 'line' | 'icon' | 'custom';
+export interface KnobTickLabelConfig {
+    show?: boolean;
+    formatter?: (mark: KnobMark, index: number) => ReactNode;
+    position?: 'inner' | 'center' | 'outer';
+    offset?: number;
+    style?: TextStyle;
+}
+export interface KnobTickLayer {
+    source?: KnobTickSource;
+    values?: number[];
+    shape?: KnobTickShape;
+    length?: number;
+    width?: number;
+    radiusOffset?: number;
+    position?: 'inner' | 'center' | 'outer';
+    color?: string;
+    inactiveColor?: string;
+    iconName?: string;
+    label?: KnobTickLabelConfig;
+    renderTick?: (context: {
+        value: number;
+        angle: number;
+        index: number;
+        isActive: boolean;
+        center: {
+            x: number;
+            y: number;
+        };
+        radius: number;
+    }) => ReactNode;
+}
+export interface KnobPointerStyle {
+    visible?: boolean;
+    length?: number;
+    width?: number;
+    offset?: number;
+    color?: string;
+    cap?: 'round' | 'butt';
+    counterweight?: {
+        size?: number;
+        color?: string;
+    };
+}
+export interface KnobArcConfig {
+    startAngle?: number;
+    sweepAngle?: number;
+    direction?: 'cw' | 'ccw';
+    clampInput?: boolean;
+    wrap?: boolean;
+}
+export type KnobProgressMode = 'none' | 'contiguous' | 'split';
+export interface KnobProgressConfig {
+    mode?: KnobProgressMode;
+    color?: string;
+    trailColor?: string;
+    roundedCaps?: boolean;
+    thickness?: number;
+}
+export interface KnobPanningConfig {
+    pivotValue?: number;
+    positiveColor?: string;
+    negativeColor?: string;
+    showZeroIndicator?: boolean;
+    valueFormatter?: (value: number) => string | ReactNode;
+    mirrorThumbOffset?: boolean;
+}
+export interface KnobAppearance {
+    ring?: KnobRingStyle;
+    fill?: KnobFillStyle;
+    thumb?: KnobThumbStyle | false;
+    ticks?: KnobTickLayer | KnobTickLayer[] | false;
+    pointer?: KnobPointerStyle | false;
+    arc?: KnobArcConfig;
+    progress?: KnobProgressConfig | false;
+    panning?: KnobPanningConfig;
+    interaction?: KnobInteractionConfig;
 }
 export interface KnobProps extends SpacingProps, LayoutProps {
+    /** Visual preset that tunes defaults for common encoder scenarios */
+    variant?: KnobVariant;
     /** Interaction mode for bounded or endless rotary behavior */
     mode?: 'bounded' | 'endless';
     /** Controlled value */
@@ -40,6 +226,8 @@ export interface KnobProps extends SpacingProps, LayoutProps {
     formatLabel?: (value: number) => ReactNode;
     /** Render the value label inside the knob */
     withLabel?: boolean;
+    /** Structured configuration for the value label block */
+    valueLabel?: KnobValueLabelConfig | false;
     /** Optional marks rendered around the control */
     marks?: KnobMark[];
     /** Restrict interaction to the supplied marks */
@@ -62,4 +250,62 @@ export interface KnobProps extends SpacingProps, LayoutProps {
     testID?: string;
     /** Screen reader label */
     accessibilityLabel?: string;
+    /** Unified surface styling and interaction overrides */
+    appearance?: KnobAppearance;
+}
+export interface KnobRootProps extends KnobProps {
+    /** Modular children composed of Knob.* sub-components */
+    children?: ReactNode;
+}
+export interface KnobFillPartProps extends KnobFillStyle {
+    visible?: boolean;
+}
+export interface KnobRingPartProps extends KnobRingStyle {
+    visible?: boolean;
+}
+export interface KnobProgressPartProps extends KnobProgressConfig {
+    visible?: boolean;
+}
+export type KnobTickLayerPartProps = KnobTickLayer;
+export interface KnobPointerPartProps extends KnobPointerStyle {
+    enabled?: boolean;
+}
+export interface KnobThumbPartProps extends KnobThumbStyle {
+    visible?: boolean;
+}
+export interface KnobValueLabelPartProps extends KnobValueLabelConfig {
+    visible?: boolean;
 }
+export type KnobPartKind = 'fill' | 'ring' | 'progress' | 'tick' | 'pointer' | 'thumb' | 'valueLabel';
+export type KnobPartEntry = {
+    kind: 'fill';
+    props: KnobFillPartProps;
+    order: number;
+} | {
+    kind: 'ring';
+    props: KnobRingPartProps;
+    order: number;
+} | {
+    kind: 'progress';
+    props: KnobProgressPartProps;
+    order: number;
+} | {
+    kind: 'tick';
+    props: KnobTickLayerPartProps;
+    order: number;
+} | {
+    kind: 'pointer';
+    props: KnobPointerPartProps;
+    order: number;
+} | {
+    kind: 'thumb';
+    props: KnobThumbPartProps;
+    order: number;
+} | {
+    kind: 'valueLabel';
+    props: KnobValueLabelPartProps;
+    order: number;
+};
+export type KnobPartComponent<P> = FC<P> & {
+    __knobPartKind: KnobPartKind;
+};

package/lib/components/Knob/utils/geometry.d.ts

@@ -0,0 +1,6 @@
+export declare const toRadians: (deg: number) => number;
+export declare const polarToCartesian: (cx: number, cy: number, radius: number, angleDeg: number) => {
+    x: number;
+    y: number;
+};
+export declare const getPositionRadius: (ringRadius: number, ringThickness: number, position?: "inner" | "center" | "outer", radiusOffset?: number) => number;

package/lib/components/Knob/utils/marks.d.ts

@@ -0,0 +1,4 @@
+import type { KnobMark } from '../types';
+export declare const normalizeMarks: (marks: KnobMark[] | undefined, min: number, max: number) => KnobMark[];
+export declare const pickClosestMark: (value: number, marks: KnobMark[]) => number;
+export declare const findClosestMarkEntry: (value: number, marks: KnobMark[]) => KnobMark | null;

package/lib/components/Knob/utils/math.d.ts

@@ -0,0 +1 @@
+export declare const clamp: (value: number, min: number, max: number) => number;

package/lib/components/ListGroup/types.d.ts

@@ -22,8 +22,8 @@ export interface ListGroupItemProps {
     disabled?: boolean;
     active?: boolean;
     danger?: boolean;
-    leftSection?: React.ReactNode;
-    rightSection?: React.ReactNode;
+    startSection?: React.ReactNode;
+    endSection?: React.ReactNode;
     style?: ViewStyle;
     textStyle?: TextStyle;
 }

package/lib/components/Markdown/Markdown.d.ts

@@ -10,6 +10,8 @@ export interface MarkdownProps extends SpacingProps {
     allowHtml?: boolean;
     /** Custom renderer overrides */
     components?: Partial<MarkdownComponentMap>;
+    /** Optional handler invoked when a markdown link is pressed */
+    onLinkPress?: (href: string) => void;
 }
 export interface MarkdownComponentMap {
     heading: (props: {
@@ -56,11 +58,14 @@ export interface MarkdownComponentMap {
     table: (props: {
         headers: React.ReactNode[];
         rows: React.ReactNode[][];
+        alignments?: (TableAlignment | undefined)[];
     }) => React.ReactNode;
     tableCell: (props: {
         children: React.ReactNode;
         isHeader?: boolean;
+        align?: TableAlignment;
     }) => React.ReactNode;
 }
+type TableAlignment = 'left' | 'center' | 'right';
 export declare const Markdown: React.FC<MarkdownProps>;
 export default Markdown;

package/lib/components/Menu/styles.d.ts

@@ -8,6 +8,6 @@ export declare function useMenuStyles(): {
     itemDangerPressed: ViewStyle;
     label: ViewStyle;
     divider: ViewStyle;
-    leftSection: ViewStyle;
-    rightSection: ViewStyle;
+    startSection: ViewStyle;
+    endSection: ViewStyle;
 };

package/lib/components/Menu/types.d.ts

@@ -41,9 +41,9 @@ export interface MenuItemProps extends SpacingProps {
     /** Whether item is disabled */
     disabled?: boolean;
     /** Left section content */
-    leftSection?: React.ReactNode;
+    startSection?: React.ReactNode;
     /** Right section content */
-    rightSection?: React.ReactNode;
+    endSection?: React.ReactNode;
     /** Item color variant */
     color?: 'default' | 'danger' | 'success' | 'warning';
     /** Whether item should close menu when pressed */

package/lib/components/MenuItemButton/MenuItemButton.d.ts

@@ -4,6 +4,7 @@ import type { PressableProps } from 'react-native';
 import type { GestureResponderEvent } from 'react-native';
 import { SpacingProps } from '../../core/utils';
 import { type ComponentSizeValue } from '../../core/theme/componentSize';
+type MenuTone = 'default' | 'primary' | 'danger' | 'success' | 'warning';
 export interface MenuItemButtonProps extends SpacingProps {
     /** Text label (alternative to children) */
     title?: string;
@@ -50,11 +51,11 @@ export interface MenuItemButtonProps extends SpacingProps {
     /** Blur handler */
     onBlur?: PressableProps['onBlur'];
     /** Semantic tone for menu styling */
-    tone?: 'default' | 'danger' | 'success' | 'warning';
+    tone?: MenuTone;
     /** Tone to apply when hovered */
-    hoverTone?: 'default' | 'danger' | 'success' | 'warning';
+    hoverTone?: MenuTone;
     /** Tone to apply when active/pressed */
-    activeTone?: 'default' | 'danger' | 'success' | 'warning';
+    activeTone?: MenuTone;
     /** Override text color for base state */
     textColor?: string;
     /** Override text color when hovered */

package/lib/components/Notice/Notice.d.ts

@@ -0,0 +1,2 @@
+import type { NoticeFactoryPayload } from './types';
+export declare const Notice: import("../../core/factory").PlatformBlocksComponent<NoticeFactoryPayload>;

package/lib/components/Notice/index.d.ts

@@ -0,0 +1,2 @@
+export { Notice } from './Notice';
+export type { NoticeProps, NoticeVariant, NoticeColor, NoticeSeverity } from './types';

package/lib/components/{Alert → Notice}/types.d.ts

@@ -2,13 +2,13 @@ import React from 'react';
 import { View, ViewStyle } from 'react-native';
 import { SpacingProps } from '../../core/utils';
 import { BorderRadiusProps } from '../../core/theme/radius';
-export type AlertVariant = 'light' | 'filled' | 'outline' | 'subtle';
-export type AlertColor = 'primary' | 'secondary' | 'success' | 'warning' | 'error' | 'gray';
-export type AlertSeverity = 'info' | 'success' | 'warning' | 'error';
-export interface AlertProps extends SpacingProps, BorderRadiusProps {
-    variant?: AlertVariant;
-    color?: AlertColor | string;
-    sev?: AlertSeverity;
+export type NoticeVariant = 'light' | 'filled' | 'outline' | 'subtle';
+export type NoticeColor = 'primary' | 'secondary' | 'success' | 'warning' | 'error' | 'gray';
+export type NoticeSeverity = 'info' | 'success' | 'warning' | 'error';
+export interface NoticeProps extends SpacingProps, BorderRadiusProps {
+    variant?: NoticeVariant;
+    color?: NoticeColor | string;
+    sev?: NoticeSeverity;
     title?: string;
     children?: React.ReactNode;
     icon?: React.ReactNode | string | null | false;
@@ -19,7 +19,7 @@ export interface AlertProps extends SpacingProps, BorderRadiusProps {
     style?: ViewStyle;
     testID?: string;
 }
-export interface AlertFactoryPayload {
-    props: AlertProps;
+export interface NoticeFactoryPayload {
+    props: NoticeProps;
     ref: View;
 }

package/lib/components/QRCode/types.d.ts

@@ -57,12 +57,6 @@ export interface QRCodeProps extends SpacingProps, LayoutProps {
     onLoadStart?: () => void;
     /** Callback when QR code finishes loading */
     onLoadEnd?: () => void;
-    /**
-     * Which QR engine to use.
-     * - internal: new in-house full spec implementation.
-     * - legacy: bundled fallback port (qr-code-ts) for comparative testing.
-     */
-    engine?: 'internal' | 'legacy';
     /** If true (or object), tapping the QR copies the value (or provided value). */
     copyOnPress?: boolean | {
         value?: string;

package/lib/components/Radio/types.d.ts

@@ -35,6 +35,8 @@ export interface RadioProps extends BaseComponentProps {
     children?: React.ReactNode;
     /** Optional icon displayed alongside the label */
     icon?: React.ReactNode | string;
+    /** Key handler for accessibility/keyboard support */
+    onKeyDown?: (event: any) => void;
 }
 export interface RadioGroupProps extends BaseComponentProps {
     /** Available options */

package/lib/components/Rating/types.d.ts

@@ -1,7 +1,8 @@
 import { View, ViewStyle } from 'react-native';
 import { SpacingProps } from '../../core/utils';
 import { SizeValue } from '../../core/theme/sizes';
-export interface RatingProps extends SpacingProps {
+import type { DisclaimerSupport } from '../_internal/Disclaimer';
+export interface RatingProps extends SpacingProps, DisclaimerSupport {
     /** Current rating value */
     value?: number;
     /** Initial rating value for uncontrolled component */

package/lib/components/Search/types.d.ts

@@ -1,5 +1,5 @@
-import type { SizeValue } from '../../core/theme/types';
-export interface SearchProps {
+import type { SizeValue, SpacingProps } from '../../core/theme/types';
+export interface SearchProps extends SpacingProps {
     value?: string;
     defaultValue?: string;
     onChange?: (value: string) => void;
@@ -11,7 +11,7 @@ export interface SearchProps {
     debounce?: number;
     clearButton?: boolean;
     loading?: boolean;
-    rightSection?: React.ReactNode;
+    endSection?: React.ReactNode;
     accessibilityLabel?: string;
     style?: any;
     /** When true, renders as a button that opens the spotlight instead of a typeable input */