@wix/site-ui 1.29.0 → 1.31.0

package/dist/Input/index.d.ts

@@ -1,11 +1,700 @@
-import { InputProps } from '@base-ui/react/input';
+import { InputProps as InputProps_2 } from '@base-ui/react/input';
 import * as React_2 from 'react';
 
-export declare const Input: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<InputProps, "ref"> & React_2.RefAttributes<HTMLElement>, "ref">, "className"> & {
+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;
+};
+
+/**
+ * Details of custom generic events emitted by Base UI components.
+ */
+declare type BaseUIGenericEventDetail<Reason extends string, CustomProperties extends object> = {
+    /**
+     * The reason for the event.
+     */
+    reason: Reason;
+    /**
+     * The native event associated with the custom event.
+     */
+    event: ReasonToEvent<Reason>;
+} & CustomProperties;
+
+declare type BaseUIGenericEventDetails<Reason extends string, CustomProperties extends object = {}> = Reason extends string ? BaseUIGenericEventDetail<Reason, CustomProperties> & {} : never;
+
+declare const cancelOpen: "cancel-open";
+
+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 type Errors = Record<string, string | string[]>;
+
+declare const escapeKey: "escape-key";
+
+export declare namespace Field {
+    export {
+        FieldRoot as Root,
+        FieldLabel as Label,
+        FieldError as Error,
+        FieldDescription as Description,
+        FieldControl as Control,
+        FieldValidity as Validity,
+        FieldItem as Item,
+        FieldValidityData as ValidityData
+    }
+}
+
+/**
+ * The form control to label and validate.
+ * Renders an `<input>` element.
+ *
+ * You can omit this part and use any Base UI input component instead. For example,
+ * [Input](https://base-ui.com/react/components/input), [Checkbox](https://base-ui.com/react/components/checkbox),
+ * or [Select](https://base-ui.com/react/components/select), among others, will work with Field out of the box.
+ *
+ * Documentation: [Base UI Field](https://base-ui.com/react/components/field)
+ */
+declare const FieldControl: React_2.ForwardRefExoticComponent<Omit<FieldControlProps, "ref"> & React_2.RefAttributes<HTMLElement>>;
+
+declare namespace FieldControl {
+    type State = FieldControlState;
+    type Props = FieldControlProps;
+    type ChangeEventReason = FieldControlChangeEventReason;
+    type ChangeEventDetails = FieldControlChangeEventDetails;
+}
+
+declare type FieldControlChangeEventDetails = BaseUIChangeEventDetails<FieldControl.ChangeEventReason>;
+
+declare type FieldControlChangeEventReason = typeof REASONS.none;
+
+declare interface FieldControlProps extends BaseUIComponentProps<'input', FieldControlState> {
+    /**
+     * Callback fired when the `value` changes. Use when controlled.
+     */
+    onValueChange?: ((value: string, eventDetails: FieldControl.ChangeEventDetails) => void) | undefined;
+    defaultValue?: React_2.ComponentProps<'input'>['defaultValue'] | undefined;
+}
+
+declare interface FieldControlState extends FieldRootState {}
+
+/**
+ * A paragraph with additional information about the field.
+ * Renders a `<p>` element.
+ *
+ * Documentation: [Base UI Field](https://base-ui.com/react/components/field)
+ */
+declare const FieldDescription: React_2.ForwardRefExoticComponent<Omit<FieldDescriptionProps, "ref"> & React_2.RefAttributes<HTMLParagraphElement>>;
+
+declare namespace FieldDescription {
+    type State = FieldDescriptionState;
+    type Props = FieldDescriptionProps;
+}
+
+declare interface FieldDescriptionProps extends BaseUIComponentProps<'p', FieldDescriptionState> {}
+
+declare interface FieldDescriptionState extends FieldRootState {}
+
+/**
+ * An error message displayed if the field control fails validation.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Field](https://base-ui.com/react/components/field)
+ */
+declare const FieldError: React_2.ForwardRefExoticComponent<Omit<FieldErrorProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+declare namespace FieldError {
+    type State = FieldErrorState;
+    type Props = FieldErrorProps;
+}
+
+declare interface FieldErrorProps extends BaseUIComponentProps<'div', FieldErrorState> {
+    /**
+     * Determines whether to show the error message according to the field's
+     * [ValidityState](https://developer.mozilla.org/en-US/docs/Web/API/ValidityState).
+     * Specifying `true` will always show the error message, and lets external libraries
+     * control the visibility.
+     */
+    match?: boolean | keyof ValidityState | undefined;
+}
+
+declare interface FieldErrorState extends FieldRootState {
+    /**
+     * The transition status of the component.
+     */
+    transitionStatus: TransitionStatus;
+}
+
+/**
+ * Groups individual items in a checkbox group or radio group with a label and description.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Field](https://base-ui.com/react/components/field)
+ */
+declare const FieldItem: React_2.ForwardRefExoticComponent<Omit<FieldItemProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+declare namespace FieldItem {
+    type State = FieldItemState;
+    type Props = FieldItemProps;
+}
+
+declare interface FieldItemProps extends BaseUIComponentProps<'div', FieldItemState> {
+    /**
+     * Whether the wrapped control should ignore user interaction.
+     * The `disabled` prop on `<Field.Root>` takes precedence over this.
+     * @default false
+     */
+    disabled?: boolean | undefined;
+}
+
+declare interface FieldItemState extends FieldRootState {}
+
+/**
+ * An accessible label that is automatically associated with the field control.
+ * Renders a `<label>` element.
+ *
+ * Documentation: [Base UI Field](https://base-ui.com/react/components/field)
+ */
+declare const FieldLabel: React_2.ForwardRefExoticComponent<Omit<FieldLabelProps, "ref"> & React_2.RefAttributes<HTMLElement>>;
+
+declare namespace FieldLabel {
+    type State = FieldLabelState;
+    type Props = FieldLabelProps;
+}
+
+declare interface FieldLabelProps extends BaseUIComponentProps<'label', FieldLabelState> {
+    /**
+     * Whether the component renders a native `<label>` element when replacing it via the `render` prop.
+     * Set to `false` if the rendered element is not a label (for example, `<div>`).
+     *
+     * This is useful to avoid inheriting label behaviors on `<button>` controls (such as `<Select.Trigger>` and `<Combobox.Trigger>`), including avoiding `:hover` on the button when hovering the label, and preventing clicks on the label from firing on the button.
+     * @default true
+     */
+    nativeLabel?: boolean | undefined;
+}
+
+declare interface FieldLabelState extends FieldRootState {}
+
+/**
+ * Groups all parts of the field.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Field](https://base-ui.com/react/components/field)
+ */
+declare const FieldRoot: React_2.ForwardRefExoticComponent<Omit<FieldRootProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+declare namespace FieldRoot {
+    type State = FieldRootState;
+    type Props = FieldRootProps;
+    type Actions = FieldRootActions;
+}
+
+declare interface FieldRootActions {
+    validate: () => void;
+}
+
+declare interface FieldRootProps extends BaseUIComponentProps<'div', FieldRootState> {
+    /**
+     * Whether the component should ignore user interaction.
+     * Takes precedence over the `disabled` prop on the `<Field.Control>` component.
+     * @default false
+     */
+    disabled?: boolean | undefined;
+    /**
+     * Identifies the field when a form is submitted.
+     * Takes precedence over the `name` prop on the `<Field.Control>` component.
+     */
+    name?: string | undefined;
+    /**
+     * A function for custom validation. Return a string or an array of strings with
+     * the error message(s) if the value is invalid, or `null` if the value is valid.
+     * Asynchronous functions are supported, but they do not prevent form submission
+     * when using `validationMode="onSubmit"`.
+     */
+    validate?: ((value: unknown, formValues: Form.Values) => string | string[] | null | Promise<string | string[] | null>) | undefined;
+    /**
+     * Determines when the field should be validated.
+     * This takes precedence over the `validationMode` prop on `<Form>`.
+     *
+     * - `onSubmit`: triggers validation when the form is submitted, and re-validates on change after submission.
+     * - `onBlur`: triggers validation when the control loses focus.
+     * - `onChange`: triggers validation on every change to the control value.
+     *
+     * @default 'onSubmit'
+     */
+    validationMode?: Form.ValidationMode | undefined;
+    /**
+     * How long to wait between `validate` callbacks if
+     * `validationMode="onChange"` is used. Specified in milliseconds.
+     * @default 0
+     */
+    validationDebounceTime?: number | undefined;
+    /**
+     * Whether the field is invalid.
+     * Useful when the field state is controlled by an external library.
+     */
+    invalid?: boolean | undefined;
+    /**
+     * Whether the field's value has been changed from its initial value.
+     * Useful when the field state is controlled by an external library.
+     */
+    dirty?: boolean | undefined;
+    /**
+     * Whether the field has been touched.
+     * Useful when the field state is controlled by an external library.
+     */
+    touched?: boolean | undefined;
+    /**
+     * A ref to imperative actions.
+     * - `validate`: Validates the field when called.
+     */
+    actionsRef?: React_2.RefObject<FieldRoot.Actions | null> | undefined;
+}
+
+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;
+}
+
+/**
+ * Used to display a custom message based on the field's validity.
+ * Requires `children` to be a function that accepts field validity state as an argument.
+ *
+ * Documentation: [Base UI Field](https://base-ui.com/react/components/field)
+ */
+declare const FieldValidity: React_2.FC<FieldValidity.Props>;
+
+declare namespace FieldValidity {
+    type State = FieldValidityState;
+    type Props = FieldValidityProps;
+}
+
+declare interface FieldValidityData {
+    state: {
+        badInput: boolean;
+        customError: boolean;
+        patternMismatch: boolean;
+        rangeOverflow: boolean;
+        rangeUnderflow: boolean;
+        stepMismatch: boolean;
+        tooLong: boolean;
+        tooShort: boolean;
+        typeMismatch: boolean;
+        valueMissing: boolean;
+        valid: boolean | null;
+    };
+    error: string;
+    errors: string[];
+    value: unknown;
+    initialValue: unknown;
+}
+
+declare interface FieldValidityProps {
+    /**
+     * A function that accepts the field validity state as an argument.
+     *
+     * ```jsx
+     * <Field.Validity>
+     *   {(validity) => {
+     *     return <div>...</div>
+     *   }}
+     * </Field.Validity>
+     * ```
+     */
+    children: (state: FieldValidityState) => React_2.ReactNode;
+}
+
+declare interface FieldValidityState extends Omit<FieldValidityData, 'state'> {
+    /**
+     * The validity state.
+     */
+    validity: FieldValidityData['state'];
+    /**
+     * The transition status of the component.
+     */
+    transitionStatus: TransitionStatus;
+}
+
+declare const focusOut: "focus-out";
+
+/**
+ * A native form element with consolidated error handling.
+ * Renders a `<form>` element.
+ *
+ * Documentation: [Base UI Form](https://base-ui.com/react/components/form)
+ */
+declare const Form: {
+    <FormValues extends Record<string, any> = Record<string, any>>(props: Form.Props<FormValues> & {
+        ref?: React_2.Ref<HTMLFormElement> | undefined;
+    }): React_2.JSX.Element;
+};
+
+declare namespace Form {
+    type Props<FormValues extends Record<string, any> = Record<string, any>> = FormProps<FormValues>;
+    type State = FormState;
+    type Actions = FormActions;
+    type ValidationMode = FormValidationMode;
+    type SubmitEventReason = FormSubmitEventReason;
+    type SubmitEventDetails = FormSubmitEventDetails;
+    type Values<FormValues extends Record<string, any> = Record<string, any>> = FormValues;
+}
+
+declare interface FormActions {
+    validate: (fieldName?: string | undefined) => void;
+}
+
+declare interface FormContext {
+    errors: Errors;
+    clearErrors: (name: string | undefined) => void;
+    formRef: React_2.RefObject<{
+        fields: Map<string, {
+            name: string | undefined;
+            /**
+             * After this returns, the field registry entry reflects the latest synchronous
+             * validity verdict. Async validators do not block submit.
+             */
+            validate: () => void;
+            validityData: FieldValidityData;
+            controlRef: React_2.RefObject<HTMLElement | null>;
+            getValue: () => unknown;
+        }>;
+    }>;
+    validationMode: Form.ValidationMode;
+    submitAttemptedRef: React_2.RefObject<boolean>;
+}
+
+declare const FormContext: React_2.Context<FormContext>;
+
+declare interface FormProps<FormValues extends Record<string, any> = Record<string, any>> extends BaseUIComponentProps<'form', FormState> {
+    /**
+     * Determines when the form should be validated.
+     * The `validationMode` prop on `<Field.Root>` takes precedence over this.
+     *
+     * - `onSubmit` (default): validates the field when the form is submitted, afterwards fields will re-validate on change.
+     * - `onBlur`: validates a field when it loses focus.
+     * - `onChange`: validates the field on every change to its value.
+     *
+     * @default 'onSubmit'
+     */
+    validationMode?: FormValidationMode | undefined;
+    /**
+     * Validation errors returned externally, typically after submission by a server or a form action.
+     * This should be an object where keys correspond to the `name` attribute on `<Field.Root>`,
+     * and values correspond to error(s) related to that field.
+     */
+    errors?: FormContext['errors'] | undefined;
+    /**
+     * Event handler called when the form is submitted.
+     * `preventDefault()` is called on the native submit event when used.
+     */
+    onFormSubmit?: ((formValues: FormValues, eventDetails: Form.SubmitEventDetails) => void) | undefined;
+    /**
+     * A ref to imperative actions.
+     * - `validate`: Validates all fields when called. Optionally pass a field name to validate a single field.
+     * @example
+     * ```tsx
+     * // validate all fields
+     * actionsRef.current.validate();
+     *
+     * // validate one field
+     * actionsRef.current.validate('email');
+     * ```
+     */
+    actionsRef?: React_2.RefObject<Form.Actions | null> | undefined;
+}
+
+declare interface FormState {}
+
+declare type FormSubmitEventDetails = BaseUIGenericEventDetails<Form.SubmitEventReason>;
+
+declare type FormSubmitEventReason = typeof REASONS.none;
+
+declare type FormValidationMode = 'onSubmit' | 'onBlur' | 'onChange';
+
+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";
+
+export declare const Input: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<InputProps_2, "ref"> & React_2.RefAttributes<HTMLElement>, "ref">, "className"> & {
     className?: string | undefined;
 } & React_2.RefAttributes<HTMLElement>>;
 
+/**
+ * A native input element that automatically works with [Field](https://base-ui.com/react/components/field).
+ * Renders an `<input>` element.
+ *
+ * Documentation: [Base UI Input](https://base-ui.com/react/components/input)
+ */
+declare const Input_2: React_2.ForwardRefExoticComponent<Omit<InputProps, "ref"> & React_2.RefAttributes<HTMLElement>>;
+
+declare namespace Input_2 {
+    type Props = InputProps;
+    type State = InputState;
+    type ChangeEventReason = InputChangeEventReason;
+    type ChangeEventDetails = InputChangeEventDetails;
+}
+
+declare const inputBlur: "input-blur";
+
+declare const inputChange: "input-change";
+
+export declare type InputChangeEventDetails = Field.Control.ChangeEventDetails;
+
+export declare type InputChangeEventReason = Field.Control.ChangeEventReason;
+
+declare const inputClear: "input-clear";
+
+declare const inputPaste: "input-paste";
+
+declare const inputPress: "input-press";
+
+export declare interface InputProps extends BaseUIComponentProps<'input', InputState> {
+    /**
+     * Callback fired when the `value` changes. Use when controlled.
+     */
+    onValueChange?: ((value: string, eventDetails: Input_2.ChangeEventDetails) => void) | undefined;
+    /**
+     * The default value of the input. Use when uncontrolled.
+     */
+    defaultValue?: Field.Control.Props['defaultValue'] | undefined;
+    /**
+     * The value of the input. Use when controlled.
+     */
+    value?: React_2.ComponentProps<'input'>['value'] | undefined;
+}
+
+export declare interface InputState extends FieldControlState {}
+
+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 const outsidePress: "outside-press";
+
+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/input";
+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 { }