# createNested API

> Auto-generated API reference for `createNested` from @vuetify/v0 (Vuetify0).
> Source of truth: https://0.vuetifyjs.com/api/create-nested

## Related

- https://0.vuetifyjs.com/composables/selection/create-nested
- https://0.vuetifyjs.com/components/disclosure/treeview
- https://0.vuetifyjs.com/composables/selection/create-group
- https://0.vuetifyjs.com/composables/selection/create-selection

## Functions

### createNested

Creates a new nested tree instance with hierarchical management.

Extends `createGroup` to support parent-child relationships, tree traversal,
and open/close state management. Perfect for tree views, nested navigation,
and hierarchical data structures.

```ts
(_options?: NestedOptions) => NestedContext<NestedTicketInput<unknown>, NestedTicket<NestedTicketInput<unknown>>>
```

### createNestedContext

Creates a new nested context with provide/inject pattern.

```ts
(_options?: NestedContextOptions) => ContextTrinity<NestedContext<NestedTicketInput<unknown>, NestedTicket<NestedTicketInput<unknown>>>>
```

### useNested

Returns the current nested instance from context.

```ts
(namespace?: string) => NestedContext<NestedTicketInput<unknown>, NestedTicket<NestedTicketInput<unknown>>>
```

## Options

| Name | Type | Default | Required | Description |
|---|---|---|---|---|
| `events` | `boolean \| undefined` | `false` | no | Enable event emission for registry operations |
| `reactive` | `boolean \| undefined` | `false` | no | Enable reactive behavior for registry operations |
| `disabled` | `MaybeRefOrGetter<boolean> \| undefined` | `false` | no | Disabled state for the entire model instance |
| `enroll` | `MaybeRefOrGetter<boolean> \| undefined` | `true` | no | Auto-select tickets on registration |
| `multiple` | `MaybeRefOrGetter<boolean> \| undefined` | `false` | no | Allow multiple tickets to be selected simultaneously |
| `mandatory` | `MaybeRefOrGetter<boolean \| "force"> \| undefined` | — | no | Controls mandatory selection behavior: - `false` (default): No mandatory selection enforcement - `true`: Prevents deselecting the last selected item - `'force'`: Automatically selects the first non-disabled item on registration |
| `open` | `NestedOpenMode \| undefined` | — | no | Controls how nodes expand/collapse. - `'multiple'` (default): Multiple nodes can be open simultaneously - `'single'`: Only one node open at a time (accordion behavior) |
| `openAll` | `boolean \| undefined` | — | no | When true, parent nodes automatically open when children are registered. Similar to `enroll` in selection composables but for open state. |
| `reveal` | `boolean \| undefined` | — | no | When true, opening a node also opens all its ancestors. Ensures the opened node is always visible in the tree. |
| `selection` | `NestedSelectionMode \| undefined` | — | no | Controls how selection cascades through the hierarchy. - `'cascade'` (default): Selecting parent selects descendants; ancestors show mixed state - `'independent'`: Each node selected independently - `'leaf'`: Only leaf nodes selectable; parent selection selects leaf descendants |
| `active` | `NestedActiveMode \| undefined` | — | no | Controls how many items can be active/highlighted simultaneously. - `'single'` (default): Only one item active at a time - `'multiple'`: Multiple items can be active simultaneously |

## Methods

| Name | Type | Description |
|---|---|---|
| `clear` | `() => void` | Clear the entire registry |
| `has` | `(id: ID) => boolean` | Check if a ticket exists by ID |
| `keys` | `() => readonly ID[]` | Get all registered IDs |
| `browse` | `(value: E["value"]) => readonly ID[] \| undefined` | Browse for an ID(s) by value |
| `lookup` | `(index: number) => ID \| undefined` | Lookup a ticket by index number |
| `get` | `(id: ID) => E \| undefined` | Get a ticket by ID |
| `upsert` | `(id: ID, ticket?: Partial<Z>, event?: string) => E` | Update or insert a ticket by ID |
| `values` | `() => readonly E[]` | Get all values of registered tickets |
| `entries` | `() => readonly [ID, E][]` | Get all entries of registered tickets |
| `unregister` | `(id: ID) => void` | Unregister a ticket by ID |
| `reindex` | `() => void` | Reset the index directory and update all tickets |
| `move` | `(id: ID, toIndex: number) => E \| undefined` | Move a ticket to a new index position |
| `reorder` | `(ids: ID[]) => void` | Reorder the registry to match a canonical permutation of ids in one pass. |
| `seek` | `(direction?: "first" \| "last", from?: number, predicate?: (ticket: E) => boolean) => E \| undefined` | Seek for a ticket based on direction and optional predicate |
| `on` | `<K extends Extensible<RegistryEventName>>(event: K, cb: RegistryEventCallback<E, K>) => void` | Listen for registry events |
| `off` | `<K extends Extensible<RegistryEventName>>(event: K, cb: RegistryEventCallback<E, K>) => void` | Stop listening for registry events |
| `emit` | `<K extends Extensible<RegistryEventName>>(event: K, data: EventPayload<E, K>) => void` | Emit an event with data |
| `dispose` | `() => void` | Clears the registry and removes all listeners |
| `batch` | `<R>(fn: () => R) => R` | Execute operations in a batch, deferring cache invalidation and event emission until complete |
| `reset` | `() => void` | Reset selection state without destroying the registry |
| `selected` | `(id: ID) => boolean` | Check if a ticket is currently selected |
| `apply` | `(values: unknown[], options?: { multiple?: boolean; }) => void` | Apply external values to the model |
| `mandate` | `() => void` | Mandate selected ID based on "mandatory" option |
| `mix` | `(ids: ID \| ID[]) => void` | Set one or more Tickets to mixed/indeterminate state by ID |
| `unmix` | `(ids: ID \| ID[]) => void` | Clear mixed/indeterminate state from one or more Tickets by ID |
| `mixed` | `(id: ID) => boolean` | Check if a ticket is in mixed/indeterminate state by ID |
| `selectAll` | `() => void` | Select all selectable (non-disabled) items |
| `unselectAll` | `() => void` | Unselect all items (respects mandatory option) |
| `toggleAll` | `() => void` | Toggle between all selected and none selected |
| `activate` | `(ids: ID \| ID[]) => void` | Activate/highlight one or more items by ID |
| `deactivate` | `(ids: ID \| ID[]) => void` | Deactivate/unhighlight one or more items by ID |
| `activated` | `(id: ID) => boolean` | Check if an item is active by ID |
| `deactivateAll` | `() => void` | Deactivate all items |
| `open` | `(ids: ID \| ID[]) => void` | Open/expand one or more items by ID |
| `close` | `(ids: ID \| ID[]) => void` | Close/collapse one or more items by ID |
| `flip` | `(ids: ID \| ID[]) => void` | Flip one or more items' open/closed state by ID |
| `opened` | `(id: ID) => boolean` | Check if an item is open by ID |
| `unfold` | `(ids: ID \| ID[]) => void` | Open node(s) and their immediate non-leaf children |
| `reveal` | `(ids: ID \| ID[]) => void` | Reveal node(s) by opening all ancestors (makes node visible without opening it) |
| `expand` | `(ids: ID \| ID[]) => void` | Fully expand node(s) and all their non-leaf descendants |
| `expandAll` | `() => void` | Expand all non-leaf nodes |
| `collapseAll` | `() => void` | Collapse all nodes |
| `toFlat` | `() => Array<{ id: ID; parentId: ID \| undefined; value: Z extends NestedTicketInput<infer V> ? V : unknown; }>` | Convert tree to flat array with parentId references |
| `getPath` | `(id: ID) => ID[]` | Get the path from root to the specified item (inclusive) |
| `getDescendants` | `(id: ID) => ID[]` | Get all descendants of an item |
| `getAncestors` | `(id: ID) => ID[]` | Get all ancestors of an item (excluding self) |
| `isLeaf` | `(id: ID) => boolean` | Check if an item is a leaf node |
| `getDepth` | `(id: ID) => number` | Get the depth level of an item in the tree |
| `isAncestorOf` | `(ancestorId: ID, descendantId: ID) => boolean` | Check if ancestorId is an ancestor of descendantId |
| `hasAncestor` | `(id: ID, ancestorId: ID) => boolean` | Check if id has ancestorId as an ancestor (semantic alias for isAncestorOf) |
| `siblings` | `(id: ID) => ID[]` | Get sibling IDs (including self). For roots, returns all root IDs. |
| `position` | `(id: ID) => number` | Get 1-indexed position among siblings (for aria-posinset). Returns 0 if not found. |
| `visibleItems` | `() => E[]` | Returns depth-first traversal of visible (open) nodes for keyboard navigation |
| `select` | `(ids: ID \| ID[]) => void` | Select item(s) and all descendants, updating ancestor mixed states |
| `unselect` | `(ids: ID \| ID[]) => void` | Unselect item(s) and all descendants, updating ancestor mixed states |
| `toggle` | `(ids: ID \| ID[]) => void` | Toggle selection with cascading behavior |
| `register` | `(registration?: NestedRegistration<Z>) => E` | Register a node with optional inline children (accepts input type, returns output type) |
| `onboard` | `(registrations: NestedRegistration<Z>[]) => E[]` | Batch register nodes with optional inline children |
| `offboard` | `(ids: ID[], cascade?: boolean) => void` | Offboard multiple nodes, optionally cascading |

## Properties

| Name | Type | Description |
|---|---|---|
| `collection` | `ReadonlyMap<ID, E>` | The collection of tickets in the registry |
| `size` | `number` | The number of tickets in the registry |
| `selectedIds` | `Reactive<Set<ID>>` | Set of currently selected ticket IDs |
| `selectedItems` | `ComputedRef<Set<E>>` | Computed Set of selected ticket instances |
| `selectedValues` | `ComputedRef<Set<E["value"] extends Ref<infer U, infer U> ? U : E["value"]>>` | Computed Set of selected ticket values |
| `disabled` | `MaybeRefOrGetter<boolean>` | Disabled state for the entire model instance |
| `multiple` | `MaybeRefOrGetter<boolean>` | Whether the selection allows multiple selections |
| `selectedIndexes` | `ComputedRef<Set<number>>` | — |
| `mixedIds` | `Reactive<Set<ID>>` | Set of mixed/indeterminate ticket IDs |
| `mixedItems` | `ComputedRef<Set<E>>` | Set of mixed/indeterminate ticket instances |
| `isNoneSelected` | `Readonly<Ref<boolean, boolean>>` | Whether no items are currently selected |
| `isAllSelected` | `ComputedRef<boolean>` | Whether all selectable (non-disabled) items are selected |
| `isMixed` | `ComputedRef<boolean>` | Whether some but not all selectable items are selected |
| `children` | `ReadonlyMap<ID, readonly ID[]>` | Map of parent IDs to arrays of child IDs. Use register/unregister to modify. |
| `parents` | `ReadonlyMap<ID, ID \| undefined>` | Map of child IDs to their parent ID (or undefined for roots). Use register/unregister to modify. |
| `openedIds` | `Reactive<Set<ID>>` | Reactive Set of opened/expanded item IDs. Use open/close/flip to modify. |
| `openedItems` | `ComputedRef<Set<E>>` | Computed Set of opened/expanded item instances |
| `activeIds` | `Reactive<Set<ID>>` | Reactive Set of active/highlighted item IDs. Use activate/deactivate to modify. |
| `activeItems` | `ComputedRef<Set<E>>` | Computed Set of active/highlighted item instances |
| `activeIndexes` | `ComputedRef<Set<number>>` | Computed Set of active item indexes (position-based) |
| `roots` | `ComputedRef<E[]>` | Computed array of root items (items with no parent) |
| `leaves` | `ComputedRef<E[]>` | Computed array of leaf items (items with no children) |