@fluentui/react-tree 9.0.0-beta.2 → 9.0.0-beta.20

package/dist/index.d.ts

@@ -6,7 +6,7 @@ import { ArrowRight } from '@fluentui/keyboard-keys';
 import { ArrowUp } from '@fluentui/keyboard-keys';
 import type { AvatarContextValue } from '@fluentui/react-avatar';
 import type { AvatarSize } from '@fluentui/react-avatar';
-import type { ButtonContextValue } from '@fluentui/react-button';
+import { ButtonContextValue } from '@fluentui/react-button';
 import type { ComponentProps } from '@fluentui/react-utilities';
 import type { ComponentState } from '@fluentui/react-utilities';
 import { ContextSelector } from '@fluentui/react-context-selector';
@@ -21,11 +21,51 @@ import { ProviderProps } from 'react';
 import * as React_2 from 'react';
 import type { Slot } from '@fluentui/react-utilities';
 import type { SlotClassNames } from '@fluentui/react-utilities';
+import { SlotRenderFunction } from '@fluentui/react-utilities';
+
+declare type FlattenedTreeItem<Props extends TreeItemProps<unknown>> = FlatTreeItemProps<NonNullable<Props['value']>> & Props;
 
 /**
  * Converts a nested structure to a flat one which can be consumed by `useFlatTreeItems`
+ * @example
+ * ```tsx
+ * const defaultItems = flattenTree_unstable([
+ *  {
+ *    children: <TreeItemLayout>level 1, item 1</TreeItemLayout>,
+ *    subtree: [
+ *      {
+ *        children: <TreeItemLayout>level 2, item 1</TreeItemLayout>,
+ *      },
+ *      {
+ *        children: <TreeItemLayout>level 2, item 2</TreeItemLayout>,
+ *      },
+ *      {
+ *        children: <TreeItemLayout>level 2, item 3</TreeItemLayout>,
+ *      },
+ *    ],
+ *  },
+ *  {
+ *    children: <TreeItemLayout>level 1, item 2</TreeItemLayout>,
+ *    subtree: [
+ *      {
+ *        children: <TreeItemLayout>level 2, item 1</TreeItemLayout>,
+ *        subtree: [
+ *          {
+ *            children: <TreeItemLayout>level 3, item 1</TreeItemLayout>,
+ *            subtree: [
+ *              {
+ *                children: <TreeItemLayout>level 4, item 1</TreeItemLayout>,
+ *              },
+ *            ],
+ *          },
+ *        ],
+ *      },
+ *    ],
+ *  },
+ * ]);
+ * ```
  */
-export declare const flattenTree_unstable: (items: NestedTreeItem[]) => FlatTreeItemProps[];
+export declare const flattenTree_unstable: <Props extends TreeItemProps<unknown>>(items: NestedTreeItem<Props>[]) => FlattenedTreeItem<Props>[];
 
 /**
  * FlatTree API to manage all required mechanisms to convert a list of items into renderable TreeItems
@@ -37,13 +77,13 @@ export declare const flattenTree_unstable: (items: NestedTreeItem[]) => FlatTree
  *
  * On simple scenarios it is advised to simply use a nested structure instead.
  */
-export declare type FlatTree = {
+export declare type FlatTree<Props extends FlatTreeItemProps<unknown> = FlatTreeItemProps> = {
     /**
      * returns the properties required for the Tree component to work properly.
      * That includes:
      * `openItems`, `onOpenChange`, `onNavigation_unstable` and `ref`
      */
-    getTreeProps(): FlatTreeProps;
+    getTreeProps(): FlatTreeProps<Props['value']>;
     /**
      * internal method used to react to an `onNavigation` event.
      * This method ensures proper navigation on keyboard and mouse interaction.
@@ -57,7 +97,7 @@ export declare type FlatTree = {
      *   event.preventDefault();
      *   const nextItem = tree.getNextNavigableItem(data);
      *   // scroll to item using virtualization scroll mechanism
-     *   if (nextItem && !targetDocument.getElementById(nextItem.id)) {
+     *   if (nextItem && document.getElementById(nextItem.id)) {
      *     listRef.current.scrollToItem(nextItem.index);
      *   }
      *   // wait for scrolling to happen and then invoke navigate method
@@ -67,39 +107,51 @@ export declare type FlatTree = {
      * };
      *```
      */
-    navigate(data: TreeNavigationData_unstable): void;
+    navigate(data: TreeNavigationData_unstable<Props['value']>): void;
     /**
      * returns next item to be focused on a navigation.
      * This method is provided to decouple the element that needs to be focused from
      *  the action of focusing it itself.
+     *
+     * On the case of TypeAhead navigation this method returns the current item.
      */
-    getNextNavigableItem(data: TreeNavigationData_unstable): FlatTreeItem | null;
-    /**
-     * returns a single flat tree item by id without iterating over the whole collection
-     */
-    getItem(id: string): FlatTreeItem | null;
+    getNextNavigableItem(visibleItems: FlatTreeItem<Props>[], data: TreeNavigationData_unstable<Props['value']>): FlatTreeItem<Props> | undefined;
     /**
-     * returns an iterable containing all visually available flat tree items
+     * an iterable containing all visually available flat tree items
      */
-    items(): Iterable<FlatTreeItem>;
+    items(): IterableIterator<FlatTreeItem<Props>>;
 };
 
-export declare type FlatTreeItem = {
-    getTreeItemProps(): Required<Pick<TreeItemProps, 'id' | 'aria-setsize' | 'aria-level' | 'aria-posinset' | 'leaf'>> & TreeItemProps;
-    parentId?: string;
-    childrenSize: number;
+/**
+ * The item that is returned by `useFlatTree`, it represents a wrapper around the properties provided to
+ * `useFlatTree` but with extra information that might be useful on flat tree scenarios
+ */
+export declare type FlatTreeItem<Props extends FlatTreeItemProps<unknown> = FlatTreeItemProps> = {
     index: number;
-    id: string;
     level: number;
+    childrenSize: number;
+    value: Props['value'];
+    parentValue: Props['parentValue'];
+    /**
+     * A reference to the element that will render the `TreeItem`,
+     * this is necessary for nodes with parents (to ensure child to parent navigation),
+     * if a node has no parent then this reference will be null.
+     */
+    ref: React_2.RefObject<HTMLDivElement>;
+    getTreeItemProps(): Required<Pick<Props, 'value' | 'aria-setsize' | 'aria-level' | 'aria-posinset' | 'itemType'>> & Omit<Props, 'parentValue'>;
 };
 
-export declare type FlatTreeItemProps = Required<Pick<TreeItemProps, 'id'>> & TreeItemProps & {
-    parentId?: string;
+export declare type FlatTreeItemProps<Value = string> = Omit<TreeItemProps<Value>, 'itemType'> & Partial<Pick<TreeItemProps<Value>, 'itemType'>> & {
+    value: Value;
+    parentValue?: Value;
 };
 
-export declare type FlatTreeProps = Required<Pick<TreeProps, 'openItems' | 'onOpenChange' | 'onNavigation_unstable'> & {
+declare type FlatTreeOptions<Props extends FlatTreeItemProps<unknown> = FlatTreeItemProps> = Pick<TreeProps<Props['value']>, 'openItems' | 'defaultOpenItems' | 'onOpenChange' | 'onNavigation_unstable'>;
+
+export declare type FlatTreeProps<Value = string> = Required<Pick<TreeProps<Value>, 'openItems' | 'onOpenChange' | 'onNavigation_unstable'>> & {
     ref: React_2.Ref<HTMLDivElement>;
-}>;
+    openItems: ImmutableSet<Value>;
+};
 
 declare interface ImmutableSet<Value> {
     /**
@@ -127,10 +179,12 @@ declare interface ImmutableSet<Value> {
     [Symbol.iterator](): IterableIterator<Value>;
 }
 
-export declare type NestedTreeItem = Omit<TreeItemProps, 'subtree'> & {
-    subtree?: NestedTreeItem[];
+export declare type NestedTreeItem<Props extends TreeItemProps<unknown>> = Omit<Props, 'subtree' | 'itemType'> & {
+    subtree?: NestedTreeItem<Props>[];
 };
 
+declare type OmitWithoutExpanding<P, K extends string | number | symbol> = P extends unknown ? Omit<P, K> : P;
+
 export declare const renderTree_unstable: (state: TreeState, contextValues: TreeContextValues) => JSX.Element;
 
 /**
@@ -138,6 +192,11 @@ export declare const renderTree_unstable: (state: TreeState, contextValues: Tree
  */
 export declare const renderTreeItem_unstable: (state: TreeItemState, contextValues: TreeItemContextValues) => JSX.Element;
 
+/**
+ * Render the final JSX of TreeItemAside
+ */
+export declare const renderTreeItemAside_unstable: (state: TreeItemAsideState) => JSX.Element | null;
+
 /**
  * Render the final JSX of TreeItemLayout
  */
@@ -156,7 +215,22 @@ export declare const renderTreeItemPersonaLayout_unstable: (state: TreeItemPerso
  * an item representing a folder can be expanded to reveal the contents of the folder,
  * which may be files, folders, or both.
  */
-export declare const Tree: ForwardRefComponent<TreeProps>;
+export declare const Tree: React_2.ForwardRefExoticComponent<Omit<TreeSlots, "root"> & Omit<{
+    as?: "div" | undefined;
+} & Pick<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | React_2.RefObject<HTMLDivElement> | null | undefined;
+} & {
+    children?: React_2.ReactNode | SlotRenderFunction<Pick<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | React_2.RefObject<HTMLDivElement> | null | undefined;
+    }>;
+}, "ref"> & {
+    appearance?: "transparent" | "subtle" | "subtle-alpha" | undefined;
+    size?: "small" | "medium" | undefined;
+    openItems?: Iterable<string> | undefined;
+    defaultOpenItems?: Iterable<string> | undefined;
+    onOpenChange?(event: React_2.KeyboardEvent<HTMLElement> | React_2.MouseEvent<HTMLElement, MouseEvent>, data: TreeOpenChangeData<string>): void;
+    onNavigation_unstable?(event: React_2.KeyboardEvent<HTMLElement> | React_2.MouseEvent<HTMLElement, MouseEvent>, data: TreeNavigationData_unstable<string>): void;
+} & React_2.RefAttributes<HTMLDivElement>> & (<Value = string>(props: TreeProps<Value>) => JSX.Element);
 
 export declare const treeClassNames: SlotClassNames<TreeSlots>;
 
@@ -164,12 +238,11 @@ export declare type TreeContextValue = {
     level: number;
     appearance: 'subtle' | 'subtle-alpha' | 'transparent';
     size: 'small' | 'medium';
-    openItems: ImmutableSet<TreeItemId>;
+    openItems: ImmutableSet<unknown>;
     /**
-     * Requests dialog main component to update it's internal open state
+     * requests root Tree component to respond to some tree item event,
      */
-    requestOpenChange(data: TreeOpenChangeData): void;
-    requestNavigation(data: TreeNavigationData_unstable): void;
+    requestTreeResponse(request: TreeItemRequest<unknown>): void;
 };
 
 declare type TreeContextValues = {
@@ -177,29 +250,96 @@ declare type TreeContextValues = {
 };
 
 /**
- * TreeItem component - TODO: add more docs
+ * The `TreeItem` component represents a single item in a tree.
+ * It expects a certain order of children to work properly: the first child should be the node itself,
+ * and the second child should be a nested subtree in the form of another Tree component or a standalone TreeItem.
+ * This order follows the same order as document traversal for the TreeWalker API in JavaScript:
+ * https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker.
+ * The content and layout of a TreeItem can be defined using the TreeItemLayout or TreeItemPersonaLayout component,
+ * which should be used as a direct child of TreeItem.
+ *
+ * When a TreeItem has nested child subtree, an expand/collapse control is displayed,
+ * allowing the user to show or hide the children.
+ */
+export declare const TreeItem: React_2.ForwardRefExoticComponent<Omit<Partial<TreeItemSlots>, "root"> & Omit<{
+    as?: "div" | undefined;
+} & Pick<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | React_2.RefObject<HTMLDivElement> | null | undefined;
+} & {
+    children?: React_2.ReactNode | SlotRenderFunction<Pick<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | React_2.RefObject<HTMLDivElement> | null | undefined;
+    }>;
+} & {
+    style?: TreeItemCSSProperties | undefined;
+}, "ref"> & {
+    value?: string | undefined;
+    itemType: TreeItemType;
+} & React_2.RefAttributes<HTMLDivElement>> & (<Value = string>(props: TreeItemProps<Value>) => JSX.Element);
+
+/**
+ * TreeItemAside component - represents a custom set of actionable elements that will be visible when a certain
+ * `TreeItem` is currently "active".
+ */
+export declare const TreeItemAside: ForwardRefComponent<TreeItemAsideProps>;
+
+export declare const treeItemAsideClassNames: SlotClassNames<TreeItemAsideSlots>;
+
+/**
+ * TreeItemAside Props
+ */
+export declare type TreeItemAsideProps = ComponentProps<TreeItemAsideSlots> & {
+    /**
+     * boolean indicating if the aside content should behave as "actions"
+     *
+     * actionable elements are normally buttons, menus, or other focusable elements.
+     * Those elements are only visibly available if the given tree item is currently active.
+     */
+    actions?: boolean;
+    /**
+     * Forces visibility of the aside content, even if they're actions
+     */
+    visible?: true;
+};
+
+export declare type TreeItemAsideSlots = {
+    root: Slot<'div'>;
+};
+
+/**
+ * State used in rendering TreeItemAside
  */
-export declare const TreeItem: ForwardRefComponent<TreeItemProps>;
+export declare type TreeItemAsideState = ComponentState<TreeItemAsideSlots> & {
+    actions: boolean;
+    visible: boolean;
+    buttonContextValue: ButtonContextValue;
+};
 
 export declare const treeItemClassNames: SlotClassNames<TreeItemSlots>;
 
 declare type TreeItemContextValue = {
     isActionsVisible: boolean;
+    isAsideVisible: boolean;
+    actionsRef: React_2.Ref<HTMLDivElement>;
+    expandIconRef: React_2.Ref<HTMLDivElement>;
+    layoutRef: React_2.Ref<HTMLDivElement>;
+    subtreeRef: React_2.Ref<HTMLDivElement>;
+    value: unknown;
+    itemType: TreeItemType;
+    open: boolean;
 };
 
 declare type TreeItemContextValues = {
     treeItem: TreeItemContextValue;
-    button: ButtonContextValue;
 };
 
 declare type TreeItemCSSProperties = React_2.CSSProperties & {
     [treeItemLevelToken]?: string | number;
 };
 
-export declare type TreeItemId = string | number;
-
 /**
- * TreeItemLayout component - TODO: add more docs
+ * The `TreeItemLayout` component is used as a child of `TreeItem` to define the content and layout of a tree item.
+ * It provides a consistent visual structure for tree items in a `Tree` component.
+ * This component should only be used as a direct child of `TreeItem`.
  */
 export declare const TreeItemLayout: ForwardRefComponent<TreeItemLayoutProps>;
 
@@ -212,26 +352,32 @@ export declare type TreeItemLayoutProps = ComponentProps<Partial<TreeItemLayoutS
 
 export declare type TreeItemLayoutSlots = {
     root: Slot<'div'>;
+    /**
+     * Expand icon slot,
+     * by default renders a chevron icon to indicate opening and closing
+     */
+    expandIcon?: Slot<'div'>;
     /**
      * Icon slot that renders right before main content
      */
-    iconBefore?: Slot<'span'>;
+    iconBefore?: Slot<'div'>;
     /**
      * Icon slot that renders right after main content
      */
-    iconAfter?: Slot<'span'>;
-    aside?: Slot<'span'>;
+    iconAfter?: Slot<'div'>;
 };
 
 /**
  * State used in rendering TreeItemLayout
  */
-export declare type TreeItemLayoutState = ComponentState<TreeItemLayoutSlots> & TreeItemContextValue;
+export declare type TreeItemLayoutState = ComponentState<TreeItemLayoutSlots>;
 
 export declare const treeItemLevelToken: "--fluent-TreeItem--level";
 
 /**
- * TreeItemPersonaLayout component - TODO: add more docs
+ * The `TreeItemPersonaLayout` component is used as a child of `TreeItem` to display a `TreeItem` with a media (typically an avatar) and a description.
+ * It provides a more visually appealing representation of a `TreeItem` and is typically used to display a list of people or topics.
+ * This component should only be used as a direct child of `TreeItem`.
  */
 export declare const TreeItemPersonaLayout: ForwardRefComponent<TreeItemPersonaLayoutProps>;
 
@@ -247,120 +393,101 @@ declare type TreeItemPersonaLayoutContextValues = {
 export declare type TreeItemPersonaLayoutProps = ComponentProps<Partial<TreeItemPersonaLayoutSlots>>;
 
 export declare type TreeItemPersonaLayoutSlots = {
-    root: Slot<'span'>;
+    root: NonNullable<Slot<'div'>>;
+    /**
+     * Expand icon slot,
+     * by default renders a chevron icon to indicate opening and closing
+     */
+    expandIcon?: Slot<'div'>;
     /**
      * Avatar to display.
      */
-    media: NonNullable<Slot<'span'>>;
+    media: NonNullable<Slot<'div'>>;
     /**
      * Main text. Children of the root slot are automatically rendered here
      */
-    main: Slot<'span'>;
+    main: NonNullable<Slot<'div'>>;
     /**
      * Secondary text that describes or complements the main text
      */
-    description?: Slot<'span'>;
-    /**
-     * aside text that works as extra textual information
-     */
-    aside?: Slot<'span'>;
+    description?: Slot<'div'>;
     /**
      * A layout wrapper for the main and description slots
      */
-    content: Slot<'div'>;
+    content: NonNullable<Slot<'div'>>;
 };
 
 /**
  * State used in rendering TreeItemPersonaLayout
  */
-export declare type TreeItemPersonaLayoutState = ComponentState<TreeItemPersonaLayoutSlots> & TreeItemContextValue & {
+export declare type TreeItemPersonaLayoutState = ComponentState<TreeItemPersonaLayoutSlots> & {
     avatarSize: AvatarSize;
 };
 
 /**
  * TreeItem Props
  */
-export declare type TreeItemProps = ComponentProps<Partial<TreeItemSlots>> & {
-    /**
-     * If a TreeItem is a leaf, it'll not present the `expandIcon` slot by default.
-     * This attribute is used to force the decision if a TreeItem is a leaf or not. By not providing this property
-     * this will be inferred by the presence of a subtree as part of the TreeItem children.
-     */
-    leaf?: boolean;
+export declare type TreeItemProps<Value = string> = ComponentProps<Partial<TreeItemSlots>> & {
+    value?: Value;
+    itemType: TreeItemType;
 };
 
-export declare const TreeItemProvider: React_2.Provider<TreeItemContextValue | undefined>;
+export declare const TreeItemProvider: React_2.Provider<TreeItemContextValue | undefined> & React_2.FC<React_2.ProviderProps<TreeItemContextValue | undefined>>;
+
+declare type TreeItemRequest<Value> = {
+    itemType: TreeItemType;
+} & (OmitWithoutExpanding<TreeOpenChangeData<Value>, 'open' | 'target'> | OmitWithoutExpanding<TreeNavigationData_unstable<Value>, 'target'>);
 
 export declare type TreeItemSlots = {
     root: Slot<ExtractSlotProps<Slot<'div'> & {
         style?: TreeItemCSSProperties;
     }>>;
-    content: NonNullable<Slot<'div'>>;
-    subtree?: Slot<'span'>;
-    /**
-     * Expand icon slot,
-     * by default renders a chevron icon to indicate opening and closing
-     */
-    expandIcon?: Slot<'span'>;
-    /**
-     * Actions slot that renders on the end of tree item
-     * when the item is hovered/focused
-     */
-    actions?: Slot<'span'>;
 };
 
 /**
  * State used in rendering TreeItem
  */
-export declare type TreeItemState = ComponentState<TreeItemSlots> & {
-    open: boolean;
-    isLeaf: boolean;
+export declare type TreeItemState = ComponentState<TreeItemSlots> & TreeItemContextValue & {
     level: number;
-    /**
-     * By design, a button included on the actions slot should be small
-     */
-    buttonSize: 'small';
-    isActionsVisible: boolean;
+    itemType: TreeItemType;
 };
 
-export declare type TreeNavigationData_unstable = {
-    event: React_2.MouseEvent<HTMLElement>;
+declare type TreeItemType = 'leaf' | 'branch';
+
+export declare type TreeNavigationData_unstable<Value = string> = {
+    value: Value;
     target: HTMLElement;
+} & ({
+    event: React_2.MouseEvent<HTMLElement>;
     type: 'Click';
 } | {
     event: React_2.KeyboardEvent<HTMLElement>;
-    target: HTMLElement;
     type: 'TypeAhead';
 } | {
     event: React_2.KeyboardEvent<HTMLElement>;
-    target: HTMLElement;
     type: typeof ArrowRight;
 } | {
     event: React_2.KeyboardEvent<HTMLElement>;
-    target: HTMLElement;
     type: typeof ArrowLeft;
 } | {
     event: React_2.KeyboardEvent<HTMLElement>;
-    target: HTMLElement;
     type: typeof ArrowUp;
 } | {
     event: React_2.KeyboardEvent<HTMLElement>;
-    target: HTMLElement;
     type: typeof ArrowDown;
 } | {
     event: React_2.KeyboardEvent<HTMLElement>;
-    target: HTMLElement;
     type: typeof Home;
 } | {
     event: React_2.KeyboardEvent<HTMLElement>;
-    target: HTMLElement;
     type: typeof End;
-};
+});
 
 export declare type TreeNavigationEvent_unstable = TreeNavigationData_unstable['event'];
 
-export declare type TreeOpenChangeData = {
+export declare type TreeOpenChangeData<Value = string> = {
     open: boolean;
+    value: Value;
 } & ({
     event: React_2.MouseEvent<HTMLElement>;
     target: HTMLElement;
@@ -385,7 +512,7 @@ export declare type TreeOpenChangeData = {
 
 export declare type TreeOpenChangeEvent = TreeOpenChangeData['event'];
 
-export declare type TreeProps = ComponentProps<TreeSlots> & {
+export declare type TreeProps<Value = string> = ComponentProps<TreeSlots> & {
     /**
      * A tree item can have various appearances:
      * - 'subtle' (default): The default tree item styles.
@@ -404,13 +531,13 @@ export declare type TreeProps = ComponentProps<TreeSlots> & {
      * Controls the state of the open tree items.
      * These property is ignored for subtrees.
      */
-    openItems?: Iterable<TreeItemId>;
+    openItems?: Iterable<Value>;
     /**
      * This refers to a list of ids of opened tree items.
      * Default value for the uncontrolled state of open tree items.
      * These property is ignored for subtrees.
      */
-    defaultOpenItems?: Iterable<TreeItemId>;
+    defaultOpenItems?: Iterable<Value>;
     /**
      * Callback fired when the component changes value from open state.
      * These property is ignored for subtrees.
@@ -419,7 +546,7 @@ export declare type TreeProps = ComponentProps<TreeSlots> & {
      * @param data - A data object with relevant information,
      * such as open value and type of interaction that created the event.
      */
-    onOpenChange?(event: TreeOpenChangeEvent, data: TreeOpenChangeData): void;
+    onOpenChange?(event: TreeOpenChangeEvent, data: TreeOpenChangeData<Value>): void;
     /**
      * Callback fired when navigation happens inside the component.
      * These property is ignored for subtrees.
@@ -429,7 +556,7 @@ export declare type TreeProps = ComponentProps<TreeSlots> & {
      * @param event - a React's Synthetic event
      * @param data - A data object with relevant information,
      */
-    onNavigation_unstable?(event: TreeNavigationEvent_unstable, data: TreeNavigationData_unstable): void;
+    onNavigation_unstable?(event: TreeNavigationEvent_unstable, data: TreeNavigationData_unstable<Value>): void;
 };
 
 export declare const TreeProvider: Provider<TreeContextValue | undefined> & FC<ProviderProps<TreeContextValue | undefined>>;
@@ -441,7 +568,9 @@ export declare type TreeSlots = {
 /**
  * State used in rendering Tree
  */
-export declare type TreeState = ComponentState<TreeSlots> & TreeContextValue;
+export declare type TreeState = ComponentState<TreeSlots> & TreeContextValue & {
+    open: boolean;
+};
 
 /**
  * this hook provides FlatTree API to manage all required mechanisms to convert a list of items into renderable TreeItems
@@ -452,10 +581,10 @@ export declare type TreeState = ComponentState<TreeSlots> & TreeContextValue;
  * It should be used on cases where more complex interactions with a Tree is required.
  * On simple scenarios it is advised to simply use a nested structure instead.
  *
- * @param items - a list of tree items
+ * @param flatTreeItemProps - a list of tree items
  * @param options - in case control over the internal openItems is required
  */
-export declare function useFlatTree_unstable(items: FlatTreeItemProps[], options?: Pick<TreeProps, 'openItems' | 'defaultOpenItems'>): FlatTree;
+export declare function useFlatTree_unstable<Props extends FlatTreeItemProps<unknown> = FlatTreeItemProps>(flatTreeItemProps: Props[], options?: FlatTreeOptions<Props>): FlatTree<Props>;
 
 /**
  * Create the state required to render Tree.
@@ -481,9 +610,25 @@ export declare function useTreeContextValues_unstable(state: TreeState): TreeCon
  * @param props - props from this instance of TreeItem
  * @param ref - reference to root HTMLElement of TreeItem
  */
-export declare const useTreeItem_unstable: (props: TreeItemProps, ref: React_2.Ref<HTMLDivElement>) => TreeItemState;
+export declare function useTreeItem_unstable<Value = string>(props: TreeItemProps<Value>, ref: React_2.Ref<HTMLDivElement>): TreeItemState;
+
+/**
+ * Create the state required to render TreeItemAside.
+ *
+ * The returned state can be modified with hooks such as useTreeItemAsideStyles_unstable,
+ * before being passed to renderTreeItemAside_unstable.
+ *
+ * @param props - props from this instance of TreeItemAside
+ * @param ref - reference to root HTMLElement of TreeItemAside
+ */
+export declare const useTreeItemAside_unstable: (props: TreeItemAsideProps, ref: React_2.Ref<HTMLElement>) => TreeItemAsideState;
+
+/**
+ * Apply styling to the TreeItemAside slots based on the state
+ */
+export declare const useTreeItemAsideStyles_unstable: (state: TreeItemAsideState) => TreeItemAsideState;
 
-export declare const useTreeItemContext_unstable: () => TreeItemContextValue;
+export declare const useTreeItemContext_unstable: <T>(selector: ContextSelector<TreeItemContextValue, T>) => T;
 
 /**
  * Create the state required to render TreeItemLayout.

package/lib/Tree.js

@@ -1,2 +1 @@
 export * from './components/Tree/index';
-//# sourceMappingURL=Tree.js.map

package/lib/Tree.js.map

@@ -1 +1 @@
-{"version":3,"file":"Tree.js","sourceRoot":"../src/","sources":["packages/react-components/react-tree/src/Tree.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC","sourcesContent":["export * from './components/Tree/index';\n"]}
+{"version":3,"sources":["Tree.ts"],"sourcesContent":["export * from './components/Tree/index';\n"],"names":[],"mappings":"AAAA,cAAc,0BAA0B"}

package/lib/TreeItem.js

@@ -1,2 +1 @@
 export * from './components/TreeItem/index';
-//# sourceMappingURL=TreeItem.js.map

package/lib/TreeItem.js.map

@@ -1 +1 @@
-{"version":3,"file":"TreeItem.js","sourceRoot":"../src/","sources":["packages/react-components/react-tree/src/TreeItem.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC","sourcesContent":["export * from './components/TreeItem/index';\n"]}
+{"version":3,"sources":["TreeItem.ts"],"sourcesContent":["export * from './components/TreeItem/index';\n"],"names":[],"mappings":"AAAA,cAAc,8BAA8B"}

package/lib/TreeItemAside.js

@@ -0,0 +1 @@
+export * from './components/TreeItemAside/index';

package/lib/TreeItemAside.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["TreeItemAside.ts"],"sourcesContent":["export * from './components/TreeItemAside/index';\n"],"names":[],"mappings":"AAAA,cAAc,mCAAmC"}

package/lib/TreeItemLayout.js

@@ -1,2 +1 @@
 export * from './components/TreeItemLayout/index';
-//# sourceMappingURL=TreeItemLayout.js.map

package/lib/TreeItemLayout.js.map

@@ -1 +1 @@
-{"version":3,"file":"TreeItemLayout.js","sourceRoot":"../src/","sources":["packages/react-components/react-tree/src/TreeItemLayout.ts"],"names":[],"mappings":"AAAA,cAAc,mCAAmC,CAAC","sourcesContent":["export * from './components/TreeItemLayout/index';\n"]}
+{"version":3,"sources":["TreeItemLayout.ts"],"sourcesContent":["export * from './components/TreeItemLayout/index';\n"],"names":[],"mappings":"AAAA,cAAc,oCAAoC"}

package/lib/TreeItemPersonaLayout.js

@@ -1,2 +1 @@
 export * from './components/TreeItemPersonaLayout/index';
-//# sourceMappingURL=TreeItemPersonaLayout.js.map

package/lib/TreeItemPersonaLayout.js.map

@@ -1 +1 @@
-{"version":3,"file":"TreeItemPersonaLayout.js","sourceRoot":"../src/","sources":["packages/react-components/react-tree/src/TreeItemPersonaLayout.ts"],"names":[],"mappings":"AAAA,cAAc,0CAA0C,CAAC","sourcesContent":["export * from './components/TreeItemPersonaLayout/index';\n"]}
+{"version":3,"sources":["TreeItemPersonaLayout.ts"],"sourcesContent":["export * from './components/TreeItemPersonaLayout/index';\n"],"names":[],"mappings":"AAAA,cAAc,2CAA2C"}