@wix/site-ui 1.29.0 → 1.31.0

package/dist/Breadcrumbs/index.js

@@ -1,7 +1,7 @@
 import { jsx } from "react/jsx-runtime";
-import { NavigationMenu } from "@base-ui/react/navigation-menu";
 import { ChevronLeft, ChevronRight } from "@wix/wix-ui-icons-common";
 import clsx from "clsx";
+import { NavigationMenuLink_NavigationMenuLink, NavigationMenuItem_NavigationMenuItem, NavigationMenuList_NavigationMenuList, NavigationMenuRoot_NavigationMenuRoot } from "../6588.js";
 import * as __rspack_external_react from "react";
 const Breadcrumbs_module = {
     root: "root-uwc56U",
@@ -20,7 +20,7 @@ const BreadcrumbsContext = /*#__PURE__*/ __rspack_external_react.createContext({
 const List = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, children, ...props }, ref)=>{
     const { separator } = __rspack_external_react.useContext(BreadcrumbsContext);
     const childArray = __rspack_external_react.Children.toArray(children);
-    return /*#__PURE__*/ jsx(NavigationMenu.List, {
+    return /*#__PURE__*/ jsx(NavigationMenuList_NavigationMenuList, {
         ref: ref,
         className: clsx(Breadcrumbs_module.list, className),
         ...props,
@@ -37,12 +37,12 @@ const List = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, chil
             ])
     });
 });
-const Item = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(NavigationMenu.Item, {
+const Item = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(NavigationMenuItem_NavigationMenuItem, {
         ref: ref,
         className: clsx(Breadcrumbs_module.item, className),
         ...props
     }));
-const Link = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(NavigationMenu.Link, {
+const Link = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(NavigationMenuLink_NavigationMenuLink, {
         ref: ref,
         className: clsx(Breadcrumbs_module.link, className),
         ...props
@@ -63,7 +63,7 @@ function Root({ className, dir, separator, 'aria-label': ariaLabel = 'Breadcrumb
         value: {
             separator: separator ?? defaultSeparator
         },
-        children: /*#__PURE__*/ jsx(NavigationMenu.Root, {
+        children: /*#__PURE__*/ jsx(NavigationMenuRoot_NavigationMenuRoot, {
             "aria-label": ariaLabel,
             dir: dir,
             ...props,

package/dist/Button/index.d.ts

@@ -1,21 +1,103 @@
-import { Button as Button_2 } from '@base-ui/react/button';
 import * as React_2 from 'react';
 
 declare type BaseProps = WithStringClassName<React_2.ComponentPropsWithoutRef<typeof Button_2>>;
 
-export declare const Button: React_2.ForwardRefExoticComponent<ButtonProps & React_2.RefAttributes<HTMLElement>>;
+/**
+ * Props shared by all Base UI components.
+ * Contains `className` (string or callback taking the component's state as an argument) and `render` (function to customize rendering).
+ */
+declare type BaseUIComponentProps<ElementType extends React_2.ElementType, State, RenderFunctionProps = HTMLProps> = Omit<WithBaseUIEvent<React_2.ComponentPropsWithRef<ElementType>>, 'className' | 'color' | 'defaultValue' | 'defaultChecked' | 'style'> & {
+    /**
+     * CSS class applied to the element, or a function that
+     * returns a class based on the component's state.
+     */
+    className?: string | ((state: State) => string | undefined) | undefined;
+    /**
+     * Allows you to replace the component's HTML element
+     * with a different tag, or compose it with another component.
+     *
+     * Accepts a `ReactElement` or a function that returns the element to render.
+     */
+    render?: React_2.ReactElement | ComponentRenderFn<RenderFunctionProps, State> | undefined;
+    /**
+     * Style applied to the element, or a function that
+     * returns a style object based on the component's state.
+     */
+    style?: React_2.CSSProperties | ((state: State) => React_2.CSSProperties | undefined) | undefined;
+};
+
+declare type BaseUIEvent<E extends React_2.SyntheticEvent<Element, Event>> = E & {
+    preventBaseUIHandler: () => void;
+    readonly baseUIHandlerPrevented?: boolean | undefined;
+};
+
+export declare const Button: React_2.ForwardRefExoticComponent<ButtonProps_2 & React_2.RefAttributes<HTMLElement>>;
+
+/**
+ * A button component that can be used to trigger actions.
+ * Renders a `<button>` element.
+ *
+ * Documentation: [Base UI Button](https://base-ui.com/react/components/button)
+ */
+declare const Button_2: React_2.ForwardRefExoticComponent<Omit<ButtonProps, "ref"> & React_2.RefAttributes<HTMLElement>>;
 
-declare interface ButtonProps extends BaseProps {
+declare namespace Button_2 {
+    type State = ButtonState;
+    type Props = ButtonProps;
+}
+
+export declare interface ButtonProps extends NativeButtonProps, BaseUIComponentProps<'button', ButtonState> {
+    /**
+     * Whether the button should be focusable when disabled.
+     * @default false
+     */
+    focusableWhenDisabled?: boolean | undefined;
+}
+
+declare interface ButtonProps_2 extends BaseProps {
     variant?: ButtonVariant;
 }
 
+export declare interface ButtonState {
+    /**
+     * Whether the button should ignore user interaction.
+     */
+    disabled: boolean;
+}
+
 declare type ButtonVariant = 'primary' | 'secondary' | 'tertiary';
 
-declare type WithStringClassName<P> = Omit<P, 'className'> & {
-    className?: string;
+/**
+ * Shape of the render prop: a function that takes props to be spread on the element and component's state and returns a React element.
+ *
+ * @template Props Props to be spread on the rendered element.
+ * @template State Component's internal state.
+ */
+declare type ComponentRenderFn<Props, State> = (props: Props, state: State) => React_2.ReactElement<unknown>;
+
+declare type HTMLProps<T = any> = React_2.HTMLAttributes<T> & {
+    ref?: React_2.Ref<T> | undefined;
 };
 
+declare interface NativeButtonProps {
+    /**
+     * Whether the component renders a native `<button>` element when replacing it
+     * via the `render` prop.
+     * Set to `false` if the rendered element is not a button (for example, `<div>`).
+     * @default true
+     */
+    nativeButton?: boolean | undefined;
+}
+
+/**
+ * Adds a `preventBaseUIHandler` method to all event handlers.
+ */
+declare type WithBaseUIEvent<T> = { [K in keyof T]: WithPreventBaseUIHandler<T[K]> };
+
+declare type WithPreventBaseUIHandler<T> = T extends ((event: infer E) => any) ? E extends React_2.SyntheticEvent<Element, Event> ? (event: BaseUIEvent<E>) => ReturnType<T> : T : T extends undefined ? undefined : T;
 
-export * from "@base-ui/react/button";
+declare type WithStringClassName<P> = Omit<P, 'className'> & {
+    className?: string;
+};
 
 export { }

package/dist/Button/index.js

@@ -1,16 +1,40 @@
 import { jsx } from "react/jsx-runtime";
-import { Button } from "@base-ui/react/button";
 import clsx from "clsx";
+import { useButton } from "../9189.js";
+import { useRenderElement } from "../8272.js";
 import * as __rspack_external_react from "react";
+const Button_Button = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, disabled = false, focusableWhenDisabled = false, nativeButton = true, style, ...elementProps } = componentProps;
+    const { getButtonProps, buttonRef } = useButton({
+        disabled,
+        focusableWhenDisabled,
+        native: nativeButton
+    });
+    const state = {
+        disabled
+    };
+    return useRenderElement('button', componentProps, {
+        state,
+        ref: [
+            forwardedRef,
+            buttonRef
+        ],
+        props: [
+            elementProps,
+            getButtonProps
+        ]
+    });
+});
+if ("production" !== process.env.NODE_ENV) Button_Button.displayName = "Button";
 const Button_module = {
     root: "root-kIffNe",
     primary: "primary-BOdHls",
     secondary: "secondary-O9td6z",
     tertiary: "tertiary-QWTRNC"
 };
-const Button_Button = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, variant = 'primary', ...props }, ref)=>/*#__PURE__*/ jsx(Button, {
+const Button_Button_Button = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, variant = 'primary', ...props }, ref)=>/*#__PURE__*/ jsx(Button_Button, {
         ref: ref,
         className: clsx(Button_module.root, Button_module[variant], className),
         ...props
     }));
-export { Button_Button as Button };
+export { Button_Button_Button as Button };

package/dist/Checkbox/index.d.ts

@@ -1,25 +1,445 @@
-import { CheckboxIndicatorProps } from '@base-ui/react/checkbox';
-import { CheckboxRootProps } from '@base-ui/react/checkbox';
+import { CheckboxIndicatorProps as CheckboxIndicatorProps_2 } from '@base-ui/react/checkbox';
+import { CheckboxRootProps as CheckboxRootProps_2 } from '@base-ui/react/checkbox';
 import * as React_2 from 'react';
 
+declare type BaseUIChangeEventDetail<Reason extends string, CustomProperties extends object> = {
+    /**
+     * The reason for the event.
+     */
+    reason: Reason;
+    /**
+     * The native event associated with the custom event.
+     */
+    event: ReasonToEvent<Reason>;
+    /**
+     * Cancels Base UI from handling the event.
+     */
+    cancel: () => void;
+    /**
+     * Allows the event to propagate in cases where Base UI will stop the propagation.
+     */
+    allowPropagation: () => void;
+    /**
+     * Indicates whether the event has been canceled.
+     */
+    isCanceled: boolean;
+    /**
+     * Indicates whether the event is allowed to propagate.
+     */
+    isPropagationAllowed: boolean;
+    /**
+     * The element that triggered the event, if applicable.
+     */
+    trigger: Element | undefined;
+} & CustomProperties;
+
+/**
+ * Details of custom change events emitted by Base UI components.
+ */
+declare type BaseUIChangeEventDetails<Reason extends string, CustomProperties extends object = {}> = Reason extends string ? BaseUIChangeEventDetail<Reason, CustomProperties> & {} : never;
+
+/**
+ * Props shared by all Base UI components.
+ * Contains `className` (string or callback taking the component's state as an argument) and `render` (function to customize rendering).
+ */
+declare type BaseUIComponentProps<ElementType extends React_2.ElementType, State, RenderFunctionProps = HTMLProps> = Omit<WithBaseUIEvent<React_2.ComponentPropsWithRef<ElementType>>, 'className' | 'color' | 'defaultValue' | 'defaultChecked' | 'style'> & {
+    /**
+     * CSS class applied to the element, or a function that
+     * returns a class based on the component's state.
+     */
+    className?: string | ((state: State) => string | undefined) | undefined;
+    /**
+     * Allows you to replace the component's HTML element
+     * with a different tag, or compose it with another component.
+     *
+     * Accepts a `ReactElement` or a function that returns the element to render.
+     */
+    render?: React_2.ReactElement | ComponentRenderFn<RenderFunctionProps, State> | undefined;
+    /**
+     * Style applied to the element, or a function that
+     * returns a style object based on the component's state.
+     */
+    style?: React_2.CSSProperties | ((state: State) => React_2.CSSProperties | undefined) | undefined;
+};
+
+declare type BaseUIEvent<E extends React_2.SyntheticEvent<Element, Event>> = E & {
+    preventBaseUIHandler: () => void;
+    readonly baseUIHandlerPrevented?: boolean | undefined;
+};
+
+declare const cancelOpen: "cancel-open";
+
 export declare const Checkbox: {
-    Root: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<CheckboxRootProps, "ref"> & React_2.RefAttributes<HTMLElement>, "ref">, "className"> & {
+    Root: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<CheckboxRootProps_2, "ref"> & React_2.RefAttributes<HTMLElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & {
         size?: number | undefined;
     } & React_2.RefAttributes<HTMLElement>>;
-    Indicator: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<CheckboxIndicatorProps, "ref"> & React_2.RefAttributes<HTMLSpanElement>, "ref">, "className"> & {
+    Indicator: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<CheckboxIndicatorProps_2, "ref"> & React_2.RefAttributes<HTMLSpanElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLSpanElement>>;
 };
 
+/**
+ * Indicates whether the checkbox is ticked.
+ * Renders a `<span>` element.
+ *
+ * Documentation: [Base UI Checkbox](https://base-ui.com/react/components/checkbox)
+ */
+export declare const CheckboxIndicator: React_2.ForwardRefExoticComponent<Omit<CheckboxIndicatorProps, "ref"> & React_2.RefAttributes<HTMLSpanElement>>;
+
+export declare namespace CheckboxIndicator {
+    export type State = CheckboxIndicatorState;
+    export type Props = CheckboxIndicatorProps;
+}
+
+export declare interface CheckboxIndicatorProps extends BaseUIComponentProps<'span', CheckboxIndicatorState> {
+    /**
+     * Whether to keep the element in the DOM when the checkbox is not checked.
+     * @default false
+     */
+    keepMounted?: boolean | undefined;
+}
+
+export declare interface CheckboxIndicatorState extends CheckboxRootState {
+    /**
+     * The transition status of the component.
+     */
+    transitionStatus: TransitionStatus;
+}
+
+/**
+ * Represents the checkbox itself.
+ * Renders a `<span>` element and a hidden `<input>` beside.
+ *
+ * Documentation: [Base UI Checkbox](https://base-ui.com/react/components/checkbox)
+ */
+export declare const CheckboxRoot: React_2.ForwardRefExoticComponent<Omit<CheckboxRootProps, "ref"> & React_2.RefAttributes<HTMLElement>>;
+
+export declare namespace CheckboxRoot {
+    export type State = CheckboxRootState;
+    export type Props = CheckboxRootProps;
+    export type ChangeEventReason = CheckboxRootChangeEventReason;
+    export type ChangeEventDetails = CheckboxRootChangeEventDetails;
+}
+
+export declare type CheckboxRootChangeEventDetails = BaseUIChangeEventDetails<CheckboxRoot.ChangeEventReason>;
+
+export declare type CheckboxRootChangeEventReason = typeof REASONS.none;
+
+export declare interface CheckboxRootProps extends NonNativeButtonProps, Omit<BaseUIComponentProps<'span', CheckboxRootState>, 'onChange' | 'value'> {
+    /**
+     * The id of the input element.
+     */
+    id?: string | undefined;
+    /**
+     * Identifies the field when a form is submitted.
+     * @default undefined
+     */
+    name?: string | undefined;
+    /**
+     * Identifies the form that owns the hidden input.
+     * Useful when the checkbox is rendered outside the form.
+     */
+    form?: string | undefined;
+    /**
+     * Whether the checkbox is currently ticked.
+     *
+     * To render an uncontrolled checkbox, use the `defaultChecked` prop instead.
+     * @default undefined
+     */
+    checked?: boolean | undefined;
+    /**
+     * Whether the checkbox is initially ticked.
+     *
+     * To render a controlled checkbox, use the `checked` prop instead.
+     * @default false
+     */
+    defaultChecked?: boolean | undefined;
+    /**
+     * Whether the component should ignore user interaction.
+     * @default false
+     */
+    disabled?: boolean | undefined;
+    /**
+     * Event handler called when the checkbox is ticked or unticked.
+     */
+    onCheckedChange?: ((checked: boolean, eventDetails: CheckboxRootChangeEventDetails) => void) | undefined;
+    /**
+     * Whether the user should be unable to tick or untick the checkbox.
+     * @default false
+     */
+    readOnly?: boolean | undefined;
+    /**
+     * Whether the user must tick the checkbox before submitting a form.
+     * @default false
+     */
+    required?: boolean | undefined;
+    /**
+     * Whether the checkbox is in a mixed state: neither ticked, nor unticked.
+     * @default false
+     */
+    indeterminate?: boolean | undefined;
+    /**
+     * A ref to access the hidden `<input>` element.
+     */
+    inputRef?: React_2.Ref<HTMLInputElement> | undefined;
+    /**
+     * Whether the checkbox controls a group of child checkboxes.
+     *
+     * Must be used in a [Checkbox Group](https://base-ui.com/react/components/checkbox-group).
+     * @default false
+     */
+    parent?: boolean | undefined;
+    /**
+     * The value submitted with the form when the checkbox is unchecked.
+     * By default, unchecked checkboxes do not submit any value, matching native checkbox behavior.
+     */
+    uncheckedValue?: string | undefined;
+    /**
+     * The value of the selected checkbox.
+     */
+    value?: string | undefined;
+}
+
+export declare interface CheckboxRootState extends FieldRootState {
+    /**
+     * Whether the checkbox is currently ticked.
+     */
+    checked: boolean;
+    /**
+     * Whether the component should ignore user interaction.
+     */
+    disabled: boolean;
+    /**
+     * Whether the user should be unable to tick or untick the checkbox.
+     */
+    readOnly: boolean;
+    /**
+     * Whether the user must tick the checkbox before submitting a form.
+     */
+    required: boolean;
+    /**
+     * Whether the checkbox is in a mixed state: neither ticked, nor unticked.
+     */
+    indeterminate: boolean;
+}
+
 export declare const CheckboxSize: {
     readonly small: 12;
     readonly medium: 16;
     readonly large: 20;
 };
 
+declare const chipRemovePress: "chip-remove-press";
+
+declare const clearPress: "clear-press";
+
+declare const closePress: "close-press";
+
+declare const closeWatcher: "close-watcher";
+
+/**
+ * Shape of the render prop: a function that takes props to be spread on the element and component's state and returns a React element.
+ *
+ * @template Props Props to be spread on the rendered element.
+ * @template State Component's internal state.
+ */
+declare type ComponentRenderFn<Props, State> = (props: Props, state: State) => React_2.ReactElement<unknown>;
+
+declare const decrementPress: "decrement-press";
+
+declare const disabled: "disabled";
+
+declare const drag: "drag";
+
+declare const escapeKey: "escape-key";
+
+declare interface FieldRootState {
+    /**
+     * Whether the component should ignore user interaction.
+     */
+    disabled: boolean;
+    /**
+     * Whether the field has been touched.
+     */
+    touched: boolean;
+    /**
+     * Whether the field value has changed from its initial value.
+     */
+    dirty: boolean;
+    /**
+     * Whether the field is valid.
+     */
+    valid: boolean | null;
+    /**
+     * Whether the field has a value.
+     */
+    filled: boolean;
+    /**
+     * Whether the field is focused.
+     */
+    focused: boolean;
+}
+
+declare const focusOut: "focus-out";
+
+declare type HTMLProps<T = any> = React_2.HTMLAttributes<T> & {
+    ref?: React_2.Ref<T> | undefined;
+};
+
+declare const imperativeAction: "imperative-action";
+
+declare const incrementPress: "increment-press";
+
+declare const initial: "initial";
+
+declare const inputBlur: "input-blur";
+
+declare const inputChange: "input-change";
+
+declare const inputClear: "input-clear";
+
+declare const inputPaste: "input-paste";
+
+declare const inputPress: "input-press";
+
+declare const itemPress: "item-press";
+
+declare const keyboard: "keyboard";
+
+declare const linkPress: "link-press";
+
+declare const listNavigation: "list-navigation";
+
+declare const missing: "missing";
+
+declare const none: "none";
+
+declare interface NonNativeButtonProps {
+    /**
+     * Whether the component renders a native `<button>` element when replacing it
+     * via the `render` prop.
+     * Set to `true` if the rendered element is a native button.
+     * @default false
+     */
+    nativeButton?: boolean | undefined;
+}
+
+declare const outsidePress: "outside-press";
+
+export declare const PARENT_CHECKBOX = "data-parent";
+
+declare const pointer: "pointer";
+
+declare namespace REASONS {
+    export {
+        none,
+        triggerPress,
+        triggerHover,
+        triggerFocus,
+        outsidePress,
+        itemPress,
+        closePress,
+        linkPress,
+        clearPress,
+        chipRemovePress,
+        trackPress,
+        incrementPress,
+        decrementPress,
+        inputChange,
+        inputClear,
+        inputBlur,
+        inputPaste,
+        inputPress,
+        focusOut,
+        escapeKey,
+        closeWatcher,
+        listNavigation,
+        keyboard,
+        pointer,
+        drag,
+        wheel,
+        scrub,
+        cancelOpen,
+        siblingOpen,
+        disabled,
+        missing,
+        initial,
+        imperativeAction,
+        swipe,
+        windowResize
+    }
+}
+
+/**
+ * Maps a change `reason` string to the corresponding native event type.
+ */
+declare type ReasonToEvent<Reason extends string> = Reason extends keyof ReasonToEventMap ? ReasonToEventMap[Reason] : Event;
+
+declare interface ReasonToEventMap {
+    [REASONS.none]: Event;
+    [REASONS.triggerPress]: MouseEvent | PointerEvent | TouchEvent | KeyboardEvent;
+    [REASONS.triggerHover]: MouseEvent;
+    [REASONS.triggerFocus]: FocusEvent;
+    [REASONS.outsidePress]: MouseEvent | PointerEvent | TouchEvent;
+    [REASONS.itemPress]: MouseEvent | KeyboardEvent | PointerEvent;
+    [REASONS.closePress]: MouseEvent | KeyboardEvent | PointerEvent;
+    [REASONS.linkPress]: MouseEvent | PointerEvent;
+    [REASONS.clearPress]: PointerEvent | MouseEvent | KeyboardEvent;
+    [REASONS.chipRemovePress]: PointerEvent | MouseEvent | KeyboardEvent;
+    [REASONS.trackPress]: PointerEvent | MouseEvent | TouchEvent;
+    [REASONS.incrementPress]: PointerEvent | MouseEvent | TouchEvent;
+    [REASONS.decrementPress]: PointerEvent | MouseEvent | TouchEvent;
+    [REASONS.inputChange]: InputEvent | Event;
+    [REASONS.inputClear]: InputEvent | FocusEvent | Event;
+    [REASONS.inputBlur]: FocusEvent;
+    [REASONS.inputPaste]: ClipboardEvent;
+    [REASONS.inputPress]: MouseEvent | PointerEvent | TouchEvent | KeyboardEvent;
+    [REASONS.focusOut]: FocusEvent | KeyboardEvent;
+    [REASONS.escapeKey]: KeyboardEvent;
+    [REASONS.closeWatcher]: Event;
+    [REASONS.listNavigation]: KeyboardEvent;
+    [REASONS.keyboard]: KeyboardEvent;
+    [REASONS.pointer]: PointerEvent;
+    [REASONS.drag]: PointerEvent | TouchEvent;
+    [REASONS.swipe]: PointerEvent | TouchEvent;
+    [REASONS.wheel]: WheelEvent;
+    [REASONS.scrub]: PointerEvent;
+    [REASONS.cancelOpen]: MouseEvent;
+    [REASONS.siblingOpen]: Event;
+    [REASONS.disabled]: Event;
+    [REASONS.missing]: Event;
+    [REASONS.initial]: Event;
+    [REASONS.imperativeAction]: Event;
+    [REASONS.windowResize]: UIEvent;
+}
+
+declare const scrub: "scrub";
+
+declare const siblingOpen: "sibling-open";
+
+declare const swipe: "swipe";
+
+declare const trackPress: "track-press";
+
+declare type TransitionStatus = 'starting' | 'ending' | 'idle' | undefined;
+
+declare const triggerFocus: "trigger-focus";
+
+declare const triggerHover: "trigger-hover";
+
+declare const triggerPress: "trigger-press";
+
+declare const wheel: "wheel";
+
+declare const windowResize: "window-resize";
+
+/**
+ * Adds a `preventBaseUIHandler` method to all event handlers.
+ */
+declare type WithBaseUIEvent<T> = { [K in keyof T]: WithPreventBaseUIHandler<T[K]> };
 
-export * from "@base-ui/react/checkbox";
+declare type WithPreventBaseUIHandler<T> = T extends ((event: infer E) => any) ? E extends React_2.SyntheticEvent<Element, Event> ? (event: BaseUIEvent<E>) => ReturnType<T> : T : T extends undefined ? undefined : T;
 
 export { }