@fluentui/react-utilities 9.0.0-nightly.f81b28ceb3.1 → 9.0.0-rc.4

package/dist/react-utilities.d.ts

@@ -11,7 +11,7 @@ export declare const anchorProperties: Record<string, number>;
 /**
  * Apply the trigger props to the children, either by calling the render function, or cloning with the new props.
  */
-export declare const applyTriggerPropsToChildren: <TTriggerProps>(children: React_2.ReactElement<any, string | ((props: any) => React_2.ReactElement<any, string | any | (new (props: any) => React_2.Component<any, any, any>)> | null) | (new (props: any) => React_2.Component<any, any, any>)> | ((props: TTriggerProps) => React_2.ReactNode) | null | undefined, triggerProps: TTriggerProps) => React_2.ReactNode;
+export declare const applyTriggerPropsToChildren: <TTriggerProps>(children: React_2.ReactElement<any, string | React_2.JSXElementConstructor<any>> | ((props: TTriggerProps) => React_2.ReactElement | null) | null | undefined, triggerProps: TTriggerProps) => React_2.ReactElement | null;
 
 /**
  * Helper type for inferring the type of the as prop from a Props type.
@@ -46,10 +46,6 @@ export declare const baseElementEvents: Record<string, number>;
  */
 export declare const baseElementProperties: Record<string, number>;
 
-export declare type BaseSlotsCompat = {
-    root: React_2.ElementType;
-};
-
 /**
  * An array of BUTTON tag properties and events.
  *
@@ -62,8 +58,6 @@ export declare const buttonProperties: Record<string, number>;
  */
 export declare function canUseDOM(): boolean;
 
-export declare type ChangeCallback<TElement extends HTMLElement, TValue, TEvent extends React_2.SyntheticEvent<TElement> | undefined> = (ev: TEvent, newValue: TValue | undefined) => void;
-
 /**
  * Clamps `value` to a number between the min and max.
  *
@@ -77,62 +71,72 @@ export declare const colGroupProperties: Record<string, number>;
 
 export declare const colProperties: Record<string, number>;
 
-export declare type ComponentProps<Shorthands extends ObjectShorthandPropsRecord, Primary extends keyof Shorthands = 'root'> = Omit<{
-    [Key in keyof Shorthands]?: ShorthandProps<NonNullable<Shorthands[Key]>>;
-}, Primary> & PropsWithoutRef<Shorthands[Primary]>;
-
-export declare type ComponentPropsCompat = {
-    as?: React_2.ElementType;
-    className?: string;
-    children?: React_2.ReactNode;
-};
+/**
+ * Defines the Props type for a component given its slots and the definition of which one is the primary slot,
+ * defaulting to root if one is not provided.
+ */
+export declare type ComponentProps<Slots extends SlotPropsRecord, Primary extends keyof Slots = 'root'> = Omit<Slots, Primary & 'root'> & PropsWithoutRef<ExtractSlotProps<Slots[Primary]>>;
 
-export declare type ComponentState<Shorthands extends ObjectShorthandPropsRecord> = {
-    components?: {
-        [Key in keyof Shorthands]-?: React_2.ComponentType<NonNullable<Shorthands[Key]> extends ObjectShorthandProps<infer P> ? P : NonNullable<Shorthands[Key]>> | (NonNullable<Shorthands[Key]> extends AsIntrinsicElement<infer As> ? As : keyof JSX.IntrinsicElements);
+/**
+ * Defines the State object of a component given its slots.
+ */
+export declare type ComponentState<Slots extends SlotPropsRecord> = {
+    components: {
+        [Key in keyof Slots]-?: React_2.ComponentType<ExtractSlotProps<Slots[Key]>> | (ExtractSlotProps<Slots[Key]> extends AsIntrinsicElement<infer As> ? As : keyof JSX.IntrinsicElements);
     };
-} & Shorthands;
+} & {
+    [Key in keyof Slots]: ReplaceNullWithUndefined<Exclude<Slots[Key], SlotShorthandValue | (Key extends 'root' ? null : never)>>;
+};
 
 /**
- * Converts a components Props type to a State type:
- * * Ensures the specified ShorthandProps are of type ObjectShorthandProps<T>
- * * Marks the given defaulted props as required (-?)
+ * Default context value to use in case there is no SSRProvider. This is fine for client-only apps.
  *
- * @template Props - The component's Props type
- * @template ShorthandPropNames - The keys of Props that correspond to ShorthandProps
- * @template DefaultedPropNames - The keys of Props that will always have a default value provided
+ * @internal
  */
-export declare type ComponentStateCompat<Props, ShorthandPropNames extends keyof Props = never, DefaultedPropNames extends keyof ResolvedShorthandPropsCompat<Props, ShorthandPropNames> = never> = RequiredPropsCompat<ResolvedShorthandPropsCompat<Props, ShorthandPropNames>, DefaultedPropNames>;
+export declare const defaultSSRContextValue: SSRContextValue;
 
 /**
- * Matches any shorthand props type.
+ * An array of DIV tag properties and events.
  *
- * This should ONLY be used in type templates as in `extends DefaultObjectShorthandProps`;
- * it shouldn't be used as the type of a slot.
+ * @public
  */
-export declare type DefaultObjectShorthandProps = ObjectShorthandProps<{
-    children?: React_2.ReactNode;
-    as?: keyof JSX.IntrinsicElements;
-}>;
+export declare const divProperties: Record<string, number>;
 
 /**
- * Default context value to use in case there is no SSRProvider. This is fine for client-only apps.
+ * HTML element types that are not allowed to have children.
  *
- * @internal
+ * Reference: https://developer.mozilla.org/en-US/docs/Glossary/Empty_element
  */
-export declare const defaultSSRContextValue: SSRContextValue;
+declare type EmptyIntrisicElements = 'area' | 'base' | 'br' | 'col' | 'embed' | 'hr' | 'img' | 'input' | 'link' | 'meta' | 'param' | 'source' | 'track' | 'wbr';
 
 /**
- * Default value can be a value or an initializer
+ * Removes SlotShorthandValue and null from the slot type, extracting just the slot's Props object.
  */
-declare type DefaultValue<TValue> = TValue | (() => TValue);
+export declare type ExtractSlotProps<S> = Exclude<S, SlotShorthandValue | null | undefined>;
 
 /**
- * An array of DIV tag properties and events.
+ * An array of FIELDSET tag properties and events.
  *
  * @public
  */
-export declare const divProperties: Record<string, number>;
+export declare const fieldsetProperties: Record<string, number>;
+
+/**
+ * Allows a component to be tagged as a FluentUI trigger component.
+ *
+ * Triggers are special-case components: they attach event listeners and other props on their child,
+ * and use them to trigger another component to show. Examples include `MenuTrigger` and `Tooltip`.
+ *
+ * A component can be tagged as a trigger as follows:
+ * ```ts
+ * const MyComponent: React.FC<MyComponentProps> & FluentTriggerComponent = ...;
+ *
+ * MyComponent.isFluentTriggerComponent = true; // MUST also set this to true
+ * ```
+ */
+export declare type FluentTriggerComponent = {
+    isFluentTriggerComponent?: boolean;
+};
 
 /**
  * An array of FORM tag properties and events.
@@ -146,10 +150,6 @@ export declare const formProperties: Record<string, number>;
  */
 export declare type ForwardRefComponent<Props> = ObscureEventName extends keyof Props ? Required<Props>[ObscureEventName] extends React_2.PointerEventHandler<infer Element> ? React_2.ForwardRefExoticComponent<Props & React_2.RefAttributes<Element>> : never : never;
 
-declare type GenericDictionary = Record<string, any>;
-
-declare type GenericDictionary_2 = Record<string, any>;
-
 /**
  * Given an element tagname and user props, filters the props to only allowed props for the given
  * element type.
@@ -175,6 +175,29 @@ export declare function getNativeElementProps<TAttributes extends React_2.HTMLAt
  */
 export declare function getNativeProps<T extends Record<string, any>>(props: Record<string, any>, allowedPropNames: string[] | Record<string, number>, excludedPropNames?: string[]): T;
 
+/**
+ * Splits the native props into ones that go to the `root` slot, and ones that go to the primary slot.
+ *
+ * This function is only for use with components that have a primary slot other than `root`.
+ * Most components should use {@link getNativeElementProps} for their root slot if it is the primary slot.
+ *
+ * @returns An object containing the native props for the `root` and primary slots.
+ */
+export declare const getPartitionedNativeProps: <Props extends Pick<React_2.HTMLAttributes<HTMLElement>, "style" | "className">, ExcludedPropKeys extends Extract<keyof Props, string> = never>({ primarySlotTagName, props, excludedPropNames, }: {
+    /** The primary slot's element type (e.g. 'div') */
+    primarySlotTagName: keyof JSX.IntrinsicElements;
+    /** The component's props object */
+    props: Props;
+    /** List of native props to exclude from the returned value */
+    excludedPropNames?: ExcludedPropKeys[] | undefined;
+}) => {
+    root: {
+        style: React_2.CSSProperties | undefined;
+        className: string | undefined;
+    };
+    primary: Omit<Props, ExcludedPropKeys>;
+};
+
 /**
  * Finds and swaps a provided key for it's right to left format.
  */
@@ -189,37 +212,39 @@ export declare const getRTLSafeKey: (key: string, dir: 'ltr' | 'rtl') => string;
  * Slots will render as null if they are rendered as primitives with undefined children.
  *
  * The slotProps will always omit the `as` prop within them, and for slots that are string
- * primitives, the props will be filtered according the the slot type. For example, if the
- * slot is rendered `as: 'a'`, the props will be filtered for acceptable anchor props.
+ * primitives, the props will be filtered according to the slot type by the type system.
+ * For example, if the slot is rendered `as: 'a'`, the props will be filtered for acceptable
+ * anchor props. Note that this is only enforced at build time by Typescript -- there is no
+ * runtime code filtering props in this function.
  *
  * @param state - State including slot definitions
- * @param slotNames - Name of which props are slots
  * @returns An object containing the `slots` map and `slotProps` map.
  */
-export declare function getSlots<R extends ObjectShorthandPropsRecord>(state: ComponentState<R>, slotNames?: (keyof R)[]): {
+export declare function getSlots<R extends SlotPropsRecord>(state: ComponentState<R>): {
     slots: Slots<R>;
-    slotProps: SlotProps<R>;
+    slotProps: ObjectSlotProps<R>;
 };
 
 /**
- * Given the state and an array of slot names, will break out `slots` and `slotProps`
- * collections.
- *
- * The root is always derived from the `as` prop.
+ * Gets the trigger element of a FluentTriggerComponent (such as Tooltip or MenuTrigger).
  *
- * Slots will render as null if they are rendered as primitives with undefined children.
- *
- * The slotProps will always omit the `as` prop within them, and for slots that are string
- * primitives, the props will be filtered according the the slot type. For example, if the
- * slot is rendered `as: 'a'`, the props will be filtered for acceptable anchor props.
+ * In the case where the immediate child is itself a FluentTriggerComponent and/or React Fragment,
+ * it returns the first descendant that is _not_ a FluentTriggerComponent or Fragment.
+ * This allows multiple triggers to be stacked, and still apply their props to the actual trigger element.
  *
- * @param state - State including slot definitions
- * @param slotNames - Name of which props are slots
- * @returns An object containing the `slots` map and `slotProps` map.
+ * For example, the following returns `<div id="child" />`:
+ * ```jsx
+ * getTriggerChild(
+ *   <Tooltip>
+ *     <MenuTrigger>
+ *       <div id="child" />
+ *     </MenuTrigger>
+ *   </Tooltip>
+ * );
+ * ```
  */
-export declare const getSlotsCompat: (state: GenericDictionary, slotNames?: readonly string[] | undefined) => {
-    slots: Record<string, any>;
-    slotProps: Record<string, any>;
+export declare const getTriggerChild: (children: React_2.ReactNode) => React_2.ReactElement & {
+    ref?: React_2.Ref<unknown>;
 };
 
 /**
@@ -256,25 +281,19 @@ export declare const imgProperties: Record<string, number>;
 export declare const inputProperties: Record<string, number>;
 
 /**
- * Define the slot arguments for a slot that supports one or more intrinsic element types, such as 'div'.
- * For slots that support custom components, use {@link ObjectShorthandProps} instead.
- *
- * The first param is the slot's default type if no `as` prop is specified.
- * The second param is an optional union of alternative types that can be specified for the `as` prop.
- *
- * ```
- * IntrinsicShorthandProps<'div'> // Slot is always div
- * IntrinsicShorthandProps<'button', 'a'> // Defaults to button, but allows as="a" with anchor-specific props
- * IntrinsicShorthandProps<'label', 'span' | 'div'>; // Defaults to label, but allows as="span" or as="div"
- * ```
+ * Helper type for {@link Slot}. Modifies `JSX.IntrinsicElements[Type]`:
+ * * Removes legacy string ref.
+ * * Disallows children for empty tags like 'img'.
  */
-export declare type IntrinsicShorthandProps<DefaultAs extends keyof JSX.IntrinsicElements, AlternateAs extends keyof JSX.IntrinsicElements = never> = IsSingleton<DefaultAs> extends false ? 'Error: first parameter to IntrinsicShorthandProps must be a single element type, not a union of types' : ({
-    as?: DefaultAs;
-} & ObjectShorthandProps<React_2.PropsWithRef<JSX.IntrinsicElements[DefaultAs]>>) | {
-    [As in AlternateAs]: {
-        as: As;
-    } & ObjectShorthandProps<React_2.PropsWithRef<JSX.IntrinsicElements[As]>>;
-}[AlternateAs];
+declare type IntrisicElementProps<Type extends keyof JSX.IntrinsicElements> = React_2.PropsWithRef<JSX.IntrinsicElements[Type]> & (Type extends EmptyIntrisicElements ? {
+    children?: never;
+} : {});
+
+/**
+ * Checks if a given element is a FluentUI trigger (e.g. `MenuTrigger` or `Tooltip`).
+ * See the {@link FluentTriggerComponent} type for more info.
+ */
+export declare const isFluentTrigger: (element: React_2.ReactElement) => boolean | undefined;
 
 /**
  * Evaluates to true if the given type contains exactly one string, or false if it is a union of strings.
@@ -302,52 +321,10 @@ export declare const labelProperties: Record<string, number>;
  */
 export declare const liProperties: Record<string, number>;
 
-/**
- * Helper which deep clones props, but respectively assigns JSX, object refs, and class names
- * appropriately.
- *
- * @param target - the target object to merge onto.
- * @param propSets - one or more prop sets to deep merge onto the target.
- */
-export declare const makeMergeProps: <TState>(options?: MergePropsOptions<TState>) => (target: TState, ...propSets: (Partial<TState> | undefined)[]) => TState;
-
-/**
- * Backwards-compatible version of makeMergeProps that has less restrictive type checking
- *
- * @deprecated Use makeMergeProps instead
- */
-export declare const makeMergePropsCompat: <TState = Record<string, any>>(options?: MergePropsOptions<Record<string, any>> | undefined) => (target: GenericDictionary_2, ...propSets: (GenericDictionary_2 | undefined)[]) => TState;
-
-export declare type MergePropsOptions<TState> = {
-    /**
-     * A list of props to deep merge. By default, `style` will
-     * always be deep merged so it's not required to be provided.
-     */
-    deepMerge?: readonly (keyof TState)[];
-};
-
-/**
- * Simple constant function for returning null, used to render empty templates in JSX.
- */
-export declare const nullRender: () => null;
-
-/**
- * Defines the slot props for a slot that supports a Component type.
- *
- * For intrinsic elements like 'div', use {@link IntrinsicShorthandProps} instead.
- */
-export declare type ObjectShorthandProps<Props extends {
-    children?: React_2.ReactNode;
-} = {}> = Props & {
-    children?: Props['children'] | ShorthandRenderFunction<Props>;
-};
-
-export declare type ObjectShorthandPropsCompat<TProps extends ComponentPropsCompat = {}> = TProps & Omit<ComponentPropsCompat, 'children'> & {
-    children?: TProps['children'] | ShorthandRenderFunctionCompat<TProps>;
+declare type ObjectSlotProps<S extends SlotPropsRecord> = {
+    [K in keyof S]-?: ExtractSlotProps<S[K]> extends AsIntrinsicElement<infer As> ? UnionToIntersection<JSX.IntrinsicElements[As]> : ExtractSlotProps<S[K]> extends React_2.ComponentType<infer P> ? P : never;
 };
 
-export declare type ObjectShorthandPropsRecord = Record<string, DefaultObjectShorthandProps | undefined>;
-
 /**
  * This is part of a hack to infer the element type from a native element *props* type.
  * The only place the original element is found in a native props type (at least that's workable
@@ -384,16 +361,11 @@ export declare const olProperties: Record<string, number>;
  */
 export declare function omit<TObj extends Record<string, any>, Exclusions extends (keyof TObj)[]>(obj: TObj, exclusions: Exclusions): Omit<TObj, Exclusions[number]>;
 
-/**
- * Similar to React.Children.only, but drills into fragments rather than treating them as a single child
- */
-export declare const onlyChild: <P>(child: string | number | boolean | {} | React_2.ReactNodeArray | React_2.ReactPortal | React_2.ReactElement<P, string | ((props: any) => React_2.ReactElement<any, string | any | (new (props: any) => React_2.Component<any, any, any>)> | null) | (new (props: any) => React_2.Component<any, any, any>)> | null | undefined) => React_2.ReactElement<P, string | ((props: any) => React_2.ReactElement<any, string | any | (new (props: any) => React_2.Component<any, any, any>)> | null) | (new (props: any) => React_2.Component<any, any, any>)>;
-
 export declare const optionProperties: Record<string, number>;
 
 /**
  * Removes the 'ref' prop from the given Props type, leaving unions intact (such as the discriminated union created by
- * IntrinsicShorthandProps). This allows IntrinsicShorthandProps to be used with React.forwardRef.
+ * IntrinsicSlotProps). This allows IntrinsicSlotProps to be used with React.forwardRef.
  *
  * The conditional "extends unknown" (always true) exploits a quirk in the way TypeScript handles conditional
  * types, to prevent unions from being expanded.
@@ -407,12 +379,9 @@ export declare type PropsWithoutRef<P> = 'ref' extends keyof P ? (P extends unkn
 export declare type RefObjectFunction<T> = React_2.RefObject<T> & ((value: T) => void);
 
 /**
- * Helper type to mark the given props as required.
- * Similar to Required<T> except it only requires a subset of the props.
+ * If type T includes `null`, remove it and add `undefined` instead.
  */
-export declare type RequiredPropsCompat<T, K extends keyof T> = Omit<T, K> & {
-    [P in K]-?: T[P];
-};
+export declare type ReplaceNullWithUndefined<T> = T extends null ? Exclude<T, null> | undefined : T;
 
 /**
  * Resets generated IDs, should be used only in tests.
@@ -422,33 +391,23 @@ export declare type RequiredPropsCompat<T, K extends keyof T> = Omit<T, K> & {
 export declare function resetIdsForTests(): void;
 
 /**
- * Helper type to convert the given props of type ShorthandProps into ObjectShorthandProps
- */
-export declare type ResolvedShorthandPropsCompat<T, K extends keyof T> = Omit<T, K> & {
-    [P in K]: T[P] extends ShorthandPropsCompat<infer U> ? ObjectShorthandPropsCompat<U> : T[P];
-};
-
-/**
- * Resolves ShorthandProps into ObjectShorthandProps, to ensure normalization of the signature
+ * Resolves shorthands into slot props, to ensure normalization of the signature
  * being passed down to getSlots method
- * @param value - the base ShorthandProps
- * @param options - options to resolve ShorthandProps
+ * @param value - the base shorthand props
+ * @param options - options to resolve shorthand props
  */
-export declare function resolveShorthand<Props extends DefaultObjectShorthandProps, Required extends boolean = false>(value: ShorthandProps<Props>, options?: ResolveShorthandOptions<Props, Required>): Required extends false ? Props | undefined : Props;
+export declare const resolveShorthand: ResolveShorthandFunction;
 
-export declare type ResolveShorthandOptions<Props extends Record<string, any>, Required extends boolean = false> = {
+export declare type ResolveShorthandFunction<Props extends UnknownSlotProps = UnknownSlotProps> = {
+    <P extends Props | null>(value: P | SlotShorthandValue | undefined, options?: ResolveShorthandOptions<P, true>): ReplaceNullWithUndefined<P>;
+    <P extends Props | null>(value: P | SlotShorthandValue | undefined, options?: ResolveShorthandOptions<P, boolean>): ReplaceNullWithUndefined<P> | undefined;
+};
+
+export declare type ResolveShorthandOptions<Props, Required extends boolean = false> = {
     required?: Required;
     defaultProps?: Props;
 };
 
-/**
- * Ensures that the given slots are represented using object syntax. This ensures that
- * the object can be merged along with other objects.
- * @param props - The incoming props
- * @param shorthandPropNames - An array of prop names to apply simplification to
- */
-export declare const resolveShorthandProps: <TProps, TShorthandPropNames extends keyof TProps>(props: TProps, shorthandPropNames: readonly TShorthandPropNames[]) => ResolvedShorthandPropsCompat<TProps, TShorthandPropNames>;
-
 /**
  * An array of SELECT tag properties and events.
  *
@@ -456,14 +415,6 @@ export declare const resolveShorthandProps: <TProps, TShorthandPropNames extends
  */
 export declare const selectProperties: Record<string, number>;
 
-export declare type ShorthandProps<Props extends DefaultObjectShorthandProps> = React_2.ReactChild | React_2.ReactNodeArray | React_2.ReactPortal | number | null | undefined | Props;
-
-export declare type ShorthandPropsCompat<TProps extends ComponentPropsCompat = {}> = React_2.ReactChild | React_2.ReactNodeArray | React_2.ReactPortal | number | null | undefined | ObjectShorthandPropsCompat<TProps>;
-
-export declare type ShorthandRenderFunction<Props> = (Component: React_2.ElementType<Props>, props: Omit<Props, 'children' | 'as'>) => React_2.ReactNode;
-
-export declare type ShorthandRenderFunctionCompat<TProps> = (Component: React_2.ElementType<TProps>, props: TProps) => React_2.ReactNode;
-
 /**
  * Checks if the keyboard event should preventDefault() for Enter and Spacebar keys
  *
@@ -471,20 +422,55 @@ export declare type ShorthandRenderFunctionCompat<TProps> = (Component: React_2.
  */
 export declare function shouldPreventDefaultOnKeyDown(e: KeyboardEvent | React_2.KeyboardEvent): boolean;
 
-declare type SlotProps<S extends ObjectShorthandPropsRecord> = {
-    [K in keyof S]-?: NonNullable<S[K]> extends AsIntrinsicElement<infer As> ? UnionToIntersection<JSX.IntrinsicElements[As]> : NonNullable<S[K]> extends ObjectShorthandProps<infer P> ? P : never;
-};
+/**
+ * The props type and shorthand value for a slot. Type is either a single intrinsic element like `'div'`,
+ * or a component like `typeof Button`.
+ *
+ * If a slot needs to support multiple intrinsic element types, use the `AlternateAs` param (see examples below).
+ *
+ * By default, slots can be set to `null` to prevent them from being rendered. If a slot must always be rendered,
+ * wrap with `NonNullable` (see examples below).
+ *
+ * @example
+ * ```
+ * // Intrinsic element examples:
+ * Slot<'div'> // Slot is always div
+ * Slot<'button', 'a'> // Defaults to button, but allows as="a" with anchor-specific props
+ * Slot<'span', 'div' | 'pre'> // Defaults to span, but allows as="div" or as="pre"
+ * NonNullable<Slot<'div'>> // Slot that will always be rendered (can't be set to null by the user)
+ *
+ * // Component examples:
+ * Slot<typeof Button> // Slot is always a Button, and accepts all of Button's Props
+ * NonNullable<Slot<typeof Label>> // Slot is a Label and will always be rendered (can't be set to null by the user)
+ * ```
+ */
+export declare type Slot<Type extends keyof JSX.IntrinsicElements | React_2.ComponentType | UnknownSlotProps, AlternateAs extends keyof JSX.IntrinsicElements = never> = IsSingleton<Extract<Type, string>> extends true ? WithSlotShorthandValue<Type extends keyof JSX.IntrinsicElements ? {
+    as?: Type;
+} & WithSlotRenderFunction<IntrisicElementProps<Type>> : Type extends React_2.ComponentType<infer Props> ? WithSlotRenderFunction<Props> : Type> | {
+    [As in AlternateAs]: {
+        as: As;
+    } & WithSlotRenderFunction<IntrisicElementProps<As>>;
+}[AlternateAs] | null : 'Error: First parameter to Slot must not be not a union of types. See documentation of Slot type.';
 
-export declare type SlotPropsCompat<TSlots extends BaseSlotsCompat, TProps, TRootProps extends React_2.HTMLAttributes<HTMLElement>> = {
-    [key in keyof Omit<TSlots, 'root'>]: key extends keyof TProps ? TProps[key] : any;
-} & {
-    root: TRootProps;
-};
+/**
+ * Matches any component's Slots type (such as ButtonSlots).
+ *
+ * This should ONLY be used in type templates as in `extends SlotPropsRecord`;
+ * it shouldn't be used as a component's Slots type.
+ */
+export declare type SlotPropsRecord = Record<string, UnknownSlotProps | SlotShorthandValue | null | undefined>;
+
+export declare type SlotRenderFunction<Props> = (Component: React_2.ElementType<Props>, props: Omit<Props, 'children' | 'as'>) => React_2.ReactNode;
 
-export declare type Slots<S extends ObjectShorthandPropsRecord> = {
-    [K in keyof S]-?: NonNullable<S[K]> extends AsIntrinsicElement<infer As> ? As : S[K] extends ObjectShorthandProps<infer P> ? React_2.ElementType<NonNullable<P>> : React_2.ElementType<NonNullable<S[K]>>;
+export declare type Slots<S extends SlotPropsRecord> = {
+    [K in keyof S]: ExtractSlotProps<S[K]> extends AsIntrinsicElement<infer As> ? As : ExtractSlotProps<S[K]> extends React_2.ComponentType<infer P> ? React_2.ElementType<NonNullable<P>> : React_2.ElementType<ExtractSlotProps<S[K]>>;
 };
 
+/**
+ * The shorthand value of a slot allows specifying its child
+ */
+export declare type SlotShorthandValue = React_2.ReactChild | React_2.ReactNodeArray | React_2.ReactPortal;
+
 export declare const SSRContext: React_2.Context<SSRContextValue>;
 
 /**
@@ -545,6 +531,16 @@ export declare const trProperties: Record<string, number>;
  */
 export declare type UnionToIntersection<U> = (U extends unknown ? (x: U) => U : never) extends (x: infer I) => U ? I : never;
 
+/**
+ * Matches any slot props type.
+ *
+ * This should ONLY be used in type templates as in `extends UnknownSlotProps`;
+ * it shouldn't be used as the type of a slot.
+ */
+export declare type UnknownSlotProps = Pick<React_2.HTMLAttributes<HTMLElement>, 'children' | 'className' | 'style'> & {
+    as?: keyof JSX.IntrinsicElements;
+};
+
 /**
  * Hook to store a value and generate callbacks for setting the value to true or false.
  * The identity of the callbacks will always stay the same.
@@ -578,42 +574,37 @@ export declare type UseBooleanCallbacks = {
 export declare function useConst<T>(initialValue: T | (() => T)): T;
 
 /**
- * A useState 'like' hook that allows optional user control
- * Useful for components which allow uncontrolled and controlled behaviour for users
- * @returns - https://reactjs.org/docs/hooks-state.html
+ * A `useState`-like hook to manage a value that could be either controlled or uncontrolled,
+ * such as a checked state or text input string.
+ *
+ * Unlike `setState`, it's okay to call the returned updater (dispatch) function for either a
+ * controlled or uncontrolled component. Calls will only be respected if the component is uncontrolled.
+ *
+ * @returns Same as [`useState`](https://reactjs.org/docs/hooks-reference.html#usestate): an array
+ * of the current value and an updater (dispatch) function. The updater function is referentially
+ * stable (won't change during the component's lifecycle). It can take either a new value, or a
+ * function which is passed the previous value and returns the new value. Unlike `setState`, calls
+ * to the updater function will only be respected if the component is uncontrolled.
+ * @see https://reactjs.org/docs/uncontrolled-components.html
  */
 export declare const useControllableState: <State>(options: UseControllableStateOptions<State>) => [State, React_2.Dispatch<React_2.SetStateAction<State>>];
 
 export declare type UseControllableStateOptions<State> = {
     /**
-     * User provided default state or factory initializer
+     * User-provided default state or initializer, for uncontrolled usage.
      */
     defaultState?: State | (() => State);
     /**
-     * User provided controllable state, undefined state means internal state will be used
+     * User-provided controlled state. `undefined` means internal state will be used.
      */
     state: State | undefined;
     /**
-     * Used to initialize state if all user provided states are undefined
+     * Used as the initial state if `state` and `defaultState` are both `undefined`.
+     * If `undefined` is the correct initial state, pass that here.
      */
     initialState: State;
 };
 
-/**
- * Hook to manage a value that could be either controlled or uncontrolled, such as a checked state or
- * text box string.
- * @param controlledValue - The controlled value passed in the props. This value will always be used if provided,
- * and the internal state will be updated to reflect it.
- * @param defaultUncontrolledValue - Initial value for the internal state in the uncontrolled case.
- * @returns An array of the current value and an updater callback. Like `React.useState`, the updater
- * callback always has the same identity, and it can take either a new value, or a function which
- * is passed the previous value and returns the new value.
- * @see https://reactjs.org/docs/uncontrolled-components.html
- */
-export declare function useControllableValue<TValue, TElement extends HTMLElement>(controlledValue: TValue, defaultUncontrolledValue: DefaultValue<TValue>): Readonly<[TValue, (update: React_2.SetStateAction<TValue>) => void]>;
-
-export declare function useControllableValue<TValue, TElement extends HTMLElement, TEvent extends React_2.SyntheticEvent<TElement> | undefined>(controlledValue: TValue, defaultUncontrolledValue: DefaultValue<TValue>, onChange: ChangeCallback<TElement, TValue, TEvent>): Readonly<[TValue, (update: React_2.SetStateAction<TValue>, ev?: React_2.FormEvent<TElement>) => void]>;
-
 /**
  * https://reactjs.org/docs/hooks-faq.html#how-to-read-an-often-changing-value-from-usecallback
  *
@@ -648,7 +639,7 @@ export declare function useForceUpdate(): DispatchWithoutAction;
 /**
  * Hook to generate a unique ID.
  *
- * @param prefix - Optional prefix for the ID
+ * @param prefix - Optional prefix for the ID. Defaults to 'fui-'.
  * @param providedId - Optional id provided by a parent component. Defaults to the provided value if present,
  *  without conditioning the hook call
  * @returns The ID
@@ -672,6 +663,25 @@ export declare const useIsomorphicLayoutEffect: typeof React_2.useEffect;
  */
 export declare function useIsSSR(): boolean;
 
+/**
+ * Combine two event callbacks into a single callback function that calls each one in order.
+ *
+ * This is useful to add an event listener to an existing element without overwriting the current listener, if any.
+ *
+ * For example:
+ * ```ts
+ * state.slot.onChange = useMergedCallbacks(state.slot.onChange, ev => {
+ *   // Handle onChange
+ * });
+ * ```
+ *
+ * @param callback1 - The first callback to be called
+ * @param callback2 - The second callback to be called
+ *
+ * @returns An event callback that calls the callbacks in order, and is stable between renders
+ */
+export declare function useMergedEventCallbacks<Args extends unknown[]>(callback1: ((...args: Args) => void) | undefined, callback2: ((...args: Args) => void) | undefined): (...args: Args) => void;
+
 /**
  * React hook to merge multiple React refs (either MutableRefObjects or ref callbacks) into a single ref callback that
  * updates all provided refs
@@ -752,4 +762,21 @@ export declare const useUnmount: (callback: () => void) => void;
  */
 export declare const videoProperties: Record<string, number>;
 
+/**
+ * Helper type for {@link Slot}. Takes the props we want to support for a slot and adds the ability for `children`
+ * to be a render function that takes those props.
+ */
+declare type WithSlotRenderFunction<Props extends {
+    children?: unknown;
+}> = Props & {
+    children?: Props['children'] | SlotRenderFunction<Props>;
+};
+
+/**
+ * Helper type for {@link Slot}. Adds shorthand types that are assignable to the slot's `children`.
+ */
+declare type WithSlotShorthandValue<Props extends {
+    children?: unknown;
+}> = Props | Extract<SlotShorthandValue, Props['children']>;
+
 export { }