@oracle/oraclejet-preact 14.0.0

package/types/hooks/UNSAFE_useLongPress/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+export { useLongPress } from './useLongPress';

package/types/hooks/UNSAFE_useLongPress/useLongPress.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * Licensed under The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+declare type LongPressOptions = {
+    isDisabled?: boolean;
+    minimumTime?: number;
+};
+declare type LongPressInfo = {
+    x: number;
+    y: number;
+};
+export declare function useLongPress(onLongPress: (e: LongPressInfo) => void, { isDisabled, minimumTime }?: LongPressOptions): {
+    longPressProps: Record<string, any>;
+};
+export {};

package/types/hooks/UNSAFE_useMessagesContext/MessagesContext.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+/**
+ * Messages Context
+ */
+declare type MessagesContextProps = {
+    /**
+     * An optional function that adds busy state to the root element
+     */
+    addBusyState?: (description?: string) => () => void;
+};
+/**
+ * Context which the parent custom element components can use for passing down
+ * the busy context
+ */
+export declare const MessagesContext: import("preact").Context<MessagesContextProps>;
+export {};

package/types/hooks/UNSAFE_useMessagesContext/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+export { MessagesContext } from './MessagesContext';
+export { useMessagesContext } from './useMessagesContext';

package/types/hooks/UNSAFE_useMessagesContext/useMessagesContext.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+/**
+ * Uses the MessagesContext if one is available.
+ *
+ * @returns The context from the closes provider
+ */
+export declare function useMessagesContext(): {
+    addBusyState?: ((description?: string | undefined) => () => void) | undefined;
+};

package/types/hooks/UNSAFE_useOutsideClick/index.d.ts

@@ -0,0 +1 @@
+export { useOutsideClick } from './useOutsideClick';

package/types/hooks/UNSAFE_useOutsideClick/useOutsideClick.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `useClickOutside` hook for capturing clicking outside of an element
+ */
+import { RefObject } from 'preact';
+declare type Props = {
+    /**
+     * If true outside click is disabled
+     */
+    isDisabled?: boolean;
+    /**
+     * Reference to element or array of elements relative to which outside click is performed
+     */
+    ref: RefObject<HTMLElement> | RefObject<HTMLElement>[];
+    /**
+     * Outside click callback
+     */
+    handler?: (event: MouseEvent) => void;
+};
+export declare const useOutsideClick: ({ isDisabled: disabled, ref, handler }: Props) => void;
+export {};

package/types/hooks/UNSAFE_usePan/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+export { usePan } from './usePan';

package/types/hooks/UNSAFE_usePan/usePan.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * Licensed under The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+declare type PanOptions = {
+    threshold?: number;
+    minimumTime?: number;
+    isDisabled?: boolean;
+};
+declare type PanInfo = {
+    x: number;
+    y: number;
+    status: 'start' | 'end' | 'move';
+};
+export declare function usePan(onPan: (e: PanInfo) => void, { threshold, minimumTime, isDisabled }?: PanOptions): {
+    panProps: Record<string, any>;
+};
+export {};

package/types/hooks/UNSAFE_usePrefixSuffix/index.d.ts

@@ -0,0 +1 @@
+export * from './usePrefixSuffix';

package/types/hooks/UNSAFE_usePrefixSuffix/usePrefixSuffix.d.ts

@@ -0,0 +1,20 @@
+declare type Props = {
+    baseId: string;
+    hasEndContent?: boolean;
+    hasInsideLabel?: boolean;
+    hasStartContent?: boolean;
+    hasValue?: boolean;
+    isDisabled?: boolean;
+    isFocused?: boolean;
+    labelId?: string;
+    prefix?: string;
+    suffix?: string;
+    value?: string;
+};
+export declare const usePrefixSuffix: ({ baseId, hasEndContent, hasInsideLabel, hasStartContent, hasValue, isDisabled, isFocused, labelId, prefix, suffix, value }: Props) => {
+    renderedPrefix: import("preact").JSX.Element | undefined;
+    renderedSuffix: import("preact").JSX.Element | undefined;
+    text: string | undefined;
+    ariaLabelledBy: string | undefined;
+};
+export {};

package/types/hooks/UNSAFE_usePress/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+export * from './usePress';

package/types/hooks/UNSAFE_usePress/usePress.d.ts

@@ -0,0 +1,19 @@
+export declare type PressOptions = {
+    isDisabled?: boolean;
+    isRepeat?: boolean;
+    repeatDelay?: number;
+    repeatInterval?: number;
+};
+/**
+ * Returns a click handler that can make a target element either clickable or keyboard pressable.
+ *
+ * @param onPressHandler function
+ * @param isRepeat boolean
+ * @param repeatInterval number number of ms between events for mouse and touch
+ * @param repeatDelay number number of ms before repeat events initiates
+ * @param isDisabled boolean
+ * @returns
+ */
+export declare function usePress(onPressHandler: (event: Event) => void, settings?: PressOptions): {
+    pressProps: Record<string, any>;
+};

package/types/hooks/UNSAFE_useScale/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+export { useScale } from './useScale';

package/types/hooks/UNSAFE_useScale/useScale.d.ts

@@ -0,0 +1 @@
+export declare function useScale(): "sm" | "md" | "lg";

package/types/hooks/UNSAFE_useSwipe/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+export { useSwipe } from './useSwipe';

package/types/hooks/UNSAFE_useSwipe/useSwipe.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * Licensed under The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+declare type SwipeOptions = {
+    threshold?: number;
+    maximumTime?: number;
+    tolerance?: number;
+    isDisabled?: boolean;
+};
+declare type SwipeInfo = {
+    direction: 'left' | 'right' | 'up' | 'down';
+};
+export declare function useSwipe(onSwipe: (e: SwipeInfo) => void, { threshold, maximumTime, tolerance, isDisabled }?: SwipeOptions): {
+    swipeProps: Record<string, any>;
+};
+export {};

package/types/hooks/UNSAFE_useTabbableMode/TabbableModeContext.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Context for Tabbable Mode Consumer and Provider
+ */
+/**
+ * Context props for Tabbable Mode
+ */
+declare type TabbableModeContextProps = {
+    /**
+     * State of Tabbable mode
+     * @default true
+     */
+    isTabbable: boolean;
+};
+declare const TabbableModeContext: import("preact").Context<TabbableModeContextProps>;
+export { TabbableModeContext };

package/types/hooks/UNSAFE_useTabbableMode/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+export { TabbableModeContext } from './TabbableModeContext';
+export { useTabbableMode } from './useTabbableMode';

package/types/hooks/UNSAFE_useTabbableMode/useTabbableMode.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+/**
+ * Utility hook for consuming the TabbableModeContext
+ */
+declare function useTabbableMode(): {
+    isTabbable: boolean;
+    tabbableModeProps: {
+        tabIndex: number;
+    };
+};
+export { useTabbableMode };

package/types/hooks/UNSAFE_useTap/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+export { useTap } from './useTap';

package/types/hooks/UNSAFE_useTap/useTap.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * Licensed under The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+declare type TapOptions = {
+    isDisabled?: boolean;
+};
+declare type TapInfo = {
+    x: number;
+    y: number;
+};
+/**
+ * Returns event handlers that can make a target element tapable.
+ * useTap is used for non-keyboard elements.
+ *
+ * @param onTap function
+ * @param settings object
+ * @returns
+ */
+export declare function useTap(onTap: (e: TapInfo) => void, { isDisabled }?: TapOptions): {
+    tapProps: Record<string, any>;
+};
+export {};

package/types/hooks/UNSAFE_useTextField/index.d.ts

@@ -0,0 +1 @@
+export * from './useTextField';

package/types/hooks/UNSAFE_useTextField/useTextField.d.ts

@@ -0,0 +1,44 @@
+import { ComponentProps } from 'preact';
+import { TextField } from '../../UNSAFE_TextField';
+import { InlineUserAssistance } from '../../UNSAFE_UserAssistance';
+import { FormFieldContextProps } from '../UNSAFE_useFormFieldContext';
+declare type PickedUserAssistanceProps = Pick<ComponentProps<typeof InlineUserAssistance>, 'messages'>;
+declare type UseTextFieldProps<V> = PickedUserAssistanceProps & {
+    ariaDescribedBy?: string;
+    contentVariant?: 'input' | 'textarea';
+    isDisabled?: boolean;
+    isFocused?: boolean;
+    isLoading?: boolean;
+    isReadonly?: boolean;
+    labelEdge?: ComponentProps<typeof TextField>['labelEdge'] | 'none';
+    styleVariant?: 'default' | 'embedded';
+    value?: V;
+};
+/**
+ * A custom hook to determine the props for a component that renders
+ * a text field
+ */
+export declare function useTextField<V>({ ariaDescribedBy, contentVariant, isDisabled, isFocused, isLoading, isReadonly, labelEdge, messages, styleVariant, value }: UseTextFieldProps<V>): {
+    baseId: string;
+    formFieldContext: FormFieldContextProps;
+    inputProps: {
+        id: string | undefined;
+        ariaDescribedBy: string | undefined;
+        ariaInvalid: string | undefined;
+        variant: "default" | "embedded" | undefined;
+    };
+    labelProps: {
+        forId: string | undefined;
+        id: string | undefined;
+        variant: "start" | "top" | "inside" | "insideError" | "insideWarning" | undefined;
+    };
+    textFieldProps: {
+        contentVariant: "textarea" | "input" | undefined;
+        statusVariant: "warning" | "error" | undefined;
+        styleVariant: "default" | "embedded" | undefined;
+    };
+    userAssistanceProps: {
+        id: string | undefined;
+    };
+};
+export {};

package/types/hooks/UNSAFE_useTextFieldInputHandlers/index.d.ts

@@ -0,0 +1 @@
+export { useTextFieldInputHandlers } from './useTextFieldInputHandlers';

package/types/hooks/UNSAFE_useTextFieldInputHandlers/useTextFieldInputHandlers.d.ts

@@ -0,0 +1,16 @@
+import { ValueUpdateDetail } from '../../utils/UNSAFE_valueUpdateDetail';
+declare type TextFieldInputProps = {
+    currentCommitValue?: string;
+    value?: string;
+    onInput?: (detail: ValueUpdateDetail<string>) => void;
+    onCommit?: (detail: ValueUpdateDetail<string>) => void;
+    onKeyDown?: (event: KeyboardEvent) => void;
+};
+export declare function useTextFieldInputHandlers({ currentCommitValue, value, onInput, onCommit, onKeyDown }: TextFieldInputProps): {
+    onBlur: (event: Event) => void;
+    onKeyDown: (event: KeyboardEvent) => void;
+    oncompositionstart: () => void;
+    oncompositionend: (event: Event) => void;
+    onInput: (event: Event) => void;
+};
+export {};

package/types/hooks/UNSAFE_useTheme/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+export { useTheme } from './useTheme';

package/types/hooks/UNSAFE_useTheme/useTheme.d.ts

@@ -0,0 +1,3 @@
+export declare function useTheme(): {
+    name: string;
+};

package/types/hooks/UNSAFE_useTimer/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+export { useTimer } from './useTimer';

package/types/hooks/UNSAFE_useTimer/useTimer.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+declare type Props = {
+    isStarted: boolean;
+    delay?: number;
+};
+/**
+ * Hook for a timer.
+ * @param isStarted Specifies whether the timer should be started: true to start it, false to stop
+ * it.
+ * @param delay Specifies the delay after which the timer should expire.
+ * @returns True if the timer expires, false if it was stopped before that.
+ *
+ */
+export declare function useTimer({ isStarted, delay }: Props): boolean;
+export {};

package/types/hooks/UNSAFE_useToggle/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+export { useToggle } from './useToggle';

package/types/hooks/UNSAFE_useToggle/useToggle.d.ts

@@ -0,0 +1,12 @@
+/**
+ * useToggle is a state toggle hook
+ *
+ * @param defaultValue
+ * @returns
+ */
+export declare function useToggle(defaultValue?: boolean): {
+    toggle: () => void;
+    setTrue: () => void;
+    setFalse: () => void;
+    bool: boolean;
+};

package/types/hooks/UNSAFE_useTooltip/TooltipContent.d.ts

@@ -0,0 +1,9 @@
+import { HTMLAttributesSignalExcluded } from '../../utils/UNSAFE_attributeUtils';
+declare type IntrinsicProps = Pick<HTMLAttributesSignalExcluded<HTMLDivElement>, 'children'>;
+declare type ContentProps = IntrinsicProps & {
+    isOpen: boolean;
+    isDatatip: boolean;
+    onTransitionEnd: () => void;
+};
+export declare const TooltipContent: ({ children, isOpen, isDatatip, onTransitionEnd, ...props }: ContentProps) => import("preact").JSX.Element;
+export {};

package/types/hooks/UNSAFE_useTooltip/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+export { useTooltip } from './useTooltip';
+export { useTooltipControlled } from './useTooltipControlled';

package/types/hooks/UNSAFE_useTooltip/useTooltip.d.ts

@@ -0,0 +1,15 @@
+import { useTooltipControlled } from './useTooltipControlled';
+declare type tooltipParameters = Parameters<typeof useTooltipControlled>[0];
+declare type Props = {
+    text?: string;
+    position?: tooltipParameters['position'];
+    isDisabled?: boolean;
+    anchor?: tooltipParameters['anchor'];
+    offset?: {
+        mainAxis?: number;
+        crossAxis?: number;
+    };
+    variant?: tooltipParameters['variant'];
+};
+export declare const useTooltip: ({ text, position, isDisabled, anchor, offset, variant }: Props) => ReturnType<typeof useTooltipControlled>;
+export {};

package/types/hooks/UNSAFE_useTooltip/useTooltipControlled.d.ts

@@ -0,0 +1,29 @@
+import { ComponentChild } from 'preact';
+export declare const positions: ("end" | "start" | "bottom" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end")[];
+declare type Position = typeof positions[number];
+export declare const anchorTos: ("pointer" | "element")[];
+declare type AnchorTo = typeof anchorTos[number];
+declare type AnchorModel = {
+    x: AnchorTo;
+    y: AnchorTo;
+};
+declare type Props = {
+    text?: string;
+    variant?: 'tooltip' | 'datatip';
+    isOpen: boolean;
+    position?: Position;
+    isDisabled?: boolean;
+    anchor?: AnchorModel;
+    offset?: {
+        mainAxis?: number;
+        crossAxis?: number;
+    };
+    onToggle?: (details: {
+        value: boolean;
+    }) => void;
+};
+export declare const useTooltipControlled: ({ text, isOpen, variant, position, isDisabled, anchor, offset, onToggle }: Props) => {
+    tooltipContent: ComponentChild;
+    tooltipProps: Record<string, any>;
+};
+export {};

package/types/hooks/UNSAFE_useTouch/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+export { useTouch } from './useTouch';

package/types/hooks/UNSAFE_useTouch/useTouch.d.ts

@@ -0,0 +1,11 @@
+export declare type TouchOptions = {
+    isDisabled?: boolean;
+};
+/**
+ * Get status on whether target has touch or not
+ * @returns
+ */
+export declare function useTouch(settings?: TouchOptions): {
+    isTouch: boolean;
+    touchProps: Record<string, any>;
+};

package/types/hooks/UNSAFE_useTranslationBundle/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+export { useTranslationBundle } from './useTranslationBundle';

package/types/hooks/UNSAFE_useTranslationBundle/useTranslationBundle.d.ts

@@ -0,0 +1,7 @@
+import type { TranslationBundle } from '../../UNSAFE_Environment';
+/**
+ * useTranslationBundle is a hook to get a translation bundle from the EnvironmentProvider
+ * @param bundleId
+ * @returns a translation bundle of type T
+ */
+export declare function useTranslationBundle<T extends TranslationBundle>(bundleId: string): T;

package/types/hooks/UNSAFE_useUncontrolledState/index.d.ts

@@ -0,0 +1 @@
+export { useUncontrolledState } from './useUncontrolledState';

package/types/hooks/UNSAFE_useUncontrolledState/useUncontrolledState.d.ts

@@ -0,0 +1,37 @@
+/**
+ * A custom hook for handling uncontrolled properties. These are the properties for which
+ * we need to maintain an internal state and also trigger certain callbacks whenever we
+ * update the internal state.
+ *
+ * Examples:
+ * 1. The `value` property in an uncontrolled InputText
+ *
+ * Here, we will have `value` property and a corresponding `onValueChanged` callback. When
+ * one interacts with the component and updates the value on the UI, we need to update the
+ * `value` prop accordingly. Being uncontrolled, we do not have to rely on the parent to push
+ * back the value, so we maintain an internal state for it and update the internal state.
+ * Even though we are maintaining an internal state, we still need to invoke the callback
+ * so we do that when the new value is different from the current value.
+ *
+ * We use useUncontrolledState hook for getting this behavior like follows:
+ * ```
+ * const [uncontrolledValue, setUncontrolledValue] = useUncontrolledState(value, onValueChanged);
+ * ```
+ *
+ * Whenever you want to change this value, you would simply do:
+ * ```
+ * // set the new value
+ * setUncontrolledValue(newValue);
+ * ```
+ * This call automatically calls the `onValueChanged` callback for you when the new value is different.
+ * Essentially, you might want to consider using this method if your property supports writeback. This
+ * way, whenever we update the internal state, the onPropertyChanged will be invoked automatically with
+ * the new value which would in turn writes back the new value on the prop.
+ *
+ * @param initialState The initial value for the internal state. Calling this hook again with a different
+ *                     value for this argument will not update the internal state.
+ * @param onStateChange The callback function that needs to be called whenever the state value is updated.
+ * @returns A stateful value and a setter function to update it. Here the setter function identity
+ *          is stable and won't change on re-renders (similar to useState's setter function)
+ */
+export declare function useUncontrolledState<V>(initialState?: V, onStateChange?: (value: V, ...args: any[]) => void): [V | undefined, (value: V, ...args: any[]) => void];

package/types/hooks/UNSAFE_useUser/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+export { useUser } from './useUser';

package/types/hooks/UNSAFE_useUser/useUser.d.ts

@@ -0,0 +1,5 @@
+export declare function useUser(): {
+    locale: string;
+    direction: "ltr" | "rtl";
+    forcedColors: "none" | "active";
+};

package/types/hooks/UNSAFE_useViewportIntersect/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+export { useViewportIntersect, ViewportConfig } from './useViewportIntersect';