bits-ui 2.6.2 → 2.8.0

package/dist/bits/toolbar/components/toolbar-group.svelte

@@ -2,7 +2,7 @@
 	import { type WritableBox, box } from "svelte-toolbelt";
 	import { mergeProps } from "svelte-toolbelt";
 	import type { ToolbarGroupProps } from "../types.js";
-	import { useToolbarGroup } from "../toolbar.svelte.js";
+	import { ToolbarGroupState } from "../toolbar.svelte.js";
 	import { createId } from "../../../internal/create-id.js";
 	import { noop } from "../../../internal/noop.js";
 	import { watch } from "runed";
@@ -36,7 +36,7 @@
 		}
 	);
 
-	const groupState = useToolbarGroup({
+	const groupState = ToolbarGroupState.create({
 		id: box.with(() => id),
 		disabled: box.with(() => disabled),
 		type,

package/dist/bits/toolbar/components/toolbar-link.svelte

@@ -1,6 +1,6 @@
 <script lang="ts">
 	import { box, mergeProps } from "svelte-toolbelt";
-	import { useToolbarLink } from "../toolbar.svelte.js";
+	import { ToolbarLinkState } from "../toolbar.svelte.js";
 	import type { ToolbarLinkProps } from "../types.js";
 	import { createId } from "../../../internal/create-id.js";
 
@@ -15,7 +15,7 @@
 		...restProps
 	}: ToolbarLinkProps = $props();
 
-	const linkState = useToolbarLink({
+	const linkState = ToolbarLinkState.create({
 		id: box.with(() => id),
 		ref: box.with(
 			() => ref,

package/dist/bits/toolbar/components/toolbar.svelte

@@ -1,7 +1,7 @@
 <script lang="ts">
 	import { box, mergeProps } from "svelte-toolbelt";
 	import type { ToolbarRootProps } from "../types.js";
-	import { useToolbarRoot } from "../toolbar.svelte.js";
+	import { ToolbarRootState } from "../toolbar.svelte.js";
 	import { createId } from "../../../internal/create-id.js";
 
 	const uid = $props.id();
@@ -16,7 +16,7 @@
 		...restProps
 	}: ToolbarRootProps = $props();
 
-	const rootState = useToolbarRoot({
+	const rootState = ToolbarRootState.create({
 		id: box.with(() => id),
 		orientation: box.with(() => orientation),
 		loop: box.with(() => loop),

package/dist/bits/toolbar/toolbar.svelte.d.ts

@@ -1,30 +1,32 @@
-import { type WritableBox } from "svelte-toolbelt";
-import type { ReadableBoxedValues, WritableBoxedValues } from "../../internal/box.svelte.js";
-import { type UseRovingFocusReturn } from "../../internal/use-roving-focus.svelte.js";
+import { type WritableBox, type WritableBoxedValues, type ReadableBoxedValues } from "svelte-toolbelt";
 import type { Orientation } from "../../shared/index.js";
-import type { BitsKeyboardEvent, BitsMouseEvent, WithRefProps } from "../../internal/types.js";
-export declare const toolbarAttrs: import("../../internal/attrs.js").BitsAttrs<readonly ["root", "item", "group", "group-item", "link", "button"]>;
-type ToolbarRootStateProps = WithRefProps<ReadableBoxedValues<{
+import type { BitsKeyboardEvent, BitsMouseEvent, WithRefOpts } from "../../internal/types.js";
+import { RovingFocusGroup } from "../../internal/roving-focus-group.js";
+export declare const toolbarAttrs: import("../../internal/attrs.js").CreateBitsAttrsReturn<readonly ["root", "item", "group", "group-item", "link", "button"]>;
+interface ToolbarRootStateOpts extends WithRefOpts, ReadableBoxedValues<{
     orientation: Orientation;
     loop: boolean;
-}>>;
-declare class ToolbarRootState {
-    readonly opts: ToolbarRootStateProps;
-    rovingFocusGroup: UseRovingFocusReturn;
-    constructor(opts: ToolbarRootStateProps);
+}> {
+}
+export declare class ToolbarRootState {
+    static create(opts: ToolbarRootStateOpts): ToolbarRootState;
+    readonly opts: ToolbarRootStateOpts;
+    readonly rovingFocusGroup: RovingFocusGroup;
+    constructor(opts: ToolbarRootStateOpts);
     readonly props: {
         readonly id: string;
         readonly role: "toolbar";
         readonly "data-orientation": Orientation;
     };
 }
-type ToolbarGroupBaseStateProps = WithRefProps<ReadableBoxedValues<{
+interface ToolbarGroupBaseStateOpts extends WithRefOpts, ReadableBoxedValues<{
     disabled: boolean;
-}>>;
-declare class ToolbarGroupBaseState {
-    readonly opts: ToolbarGroupBaseStateProps;
+}> {
+}
+declare abstract class ToolbarGroupBaseState {
+    readonly opts: ToolbarGroupBaseStateOpts;
     readonly root: ToolbarRootState;
-    constructor(opts: ToolbarGroupBaseStateProps, root: ToolbarRootState);
+    constructor(opts: ToolbarGroupBaseStateOpts, root: ToolbarRootState);
     readonly props: {
         readonly id: string;
         readonly role: "group";
@@ -32,41 +34,54 @@ declare class ToolbarGroupBaseState {
         readonly "data-disabled": "" | undefined;
     };
 }
-type ToolbarGroupSingleStateProps = ToolbarGroupBaseStateProps & WritableBoxedValues<{
+interface ToolbarGroupSingleStateOpts extends ToolbarGroupBaseStateOpts, WritableBoxedValues<{
     value: string;
-}>;
+}> {
+}
 declare class ToolbarGroupSingleState extends ToolbarGroupBaseState {
-    readonly opts: ToolbarGroupSingleStateProps;
+    readonly opts: ToolbarGroupSingleStateOpts;
     readonly root: ToolbarRootState;
     readonly isMulti: false;
     readonly anyPressed: boolean;
-    constructor(opts: ToolbarGroupSingleStateProps, root: ToolbarRootState);
+    constructor(opts: ToolbarGroupSingleStateOpts, root: ToolbarRootState);
     includesItem(item: string): boolean;
     toggleItem(item: string): void;
 }
-type ToolbarGroupMultipleStateProps = ToolbarGroupBaseStateProps & WritableBoxedValues<{
+interface ToolbarGroupMultipleStateOpts extends ToolbarGroupBaseStateOpts, WritableBoxedValues<{
     value: string[];
-}>;
+}> {
+}
 declare class ToolbarGroupMultipleState extends ToolbarGroupBaseState {
-    readonly opts: ToolbarGroupMultipleStateProps;
+    readonly opts: ToolbarGroupMultipleStateOpts;
     readonly root: ToolbarRootState;
     readonly isMulti: true;
     readonly anyPressed: boolean;
-    constructor(opts: ToolbarGroupMultipleStateProps, root: ToolbarRootState);
+    constructor(opts: ToolbarGroupMultipleStateOpts, root: ToolbarRootState);
     includesItem(item: string): boolean;
     toggleItem(item: string): void;
 }
-type ToolbarGroupState = ToolbarGroupSingleState | ToolbarGroupMultipleState;
-type ToolbarGroupItemStateProps = WithRefProps<ReadableBoxedValues<{
+type ToolbarGroup = ToolbarGroupSingleState | ToolbarGroupMultipleState;
+interface ToolbarGroupRootOpts extends WithRefOpts, ReadableBoxedValues<{
+    disabled: boolean;
+}> {
+    type: "single" | "multiple";
+    value: WritableBox<string> | WritableBox<string[]>;
+}
+export declare class ToolbarGroupState {
+    static create(opts: ToolbarGroupRootOpts): ToolbarGroup;
+}
+interface ToolbarGroupItemStateOpts extends WithRefOpts, ReadableBoxedValues<{
     value: string;
     disabled: boolean;
-}>>;
-declare class ToolbarGroupItemState {
+}> {
+}
+export declare class ToolbarGroupItemState {
     #private;
-    readonly opts: ToolbarGroupItemStateProps;
-    readonly group: ToolbarGroupState;
+    static create(opts: ToolbarGroupItemStateOpts): ToolbarGroupItemState;
+    readonly opts: ToolbarGroupItemStateOpts;
+    readonly group: ToolbarGroup;
     readonly root: ToolbarRootState;
-    constructor(opts: ToolbarGroupItemStateProps, group: ToolbarGroupState, root: ToolbarRootState);
+    constructor(opts: ToolbarGroupItemStateOpts, group: ToolbarGroup, root: ToolbarRootState);
     onclick(_: BitsMouseEvent): void;
     onkeydown(e: BitsKeyboardEvent): void;
     readonly isPressed: boolean;
@@ -85,12 +100,14 @@ declare class ToolbarGroupItemState {
         readonly onkeydown: (e: BitsKeyboardEvent) => void;
     };
 }
-type ToolbarLinkStateProps = WithRefProps;
-declare class ToolbarLinkState {
+interface ToolbarLinkStateOpts extends WithRefOpts {
+}
+export declare class ToolbarLinkState {
     #private;
-    readonly opts: ToolbarLinkStateProps;
+    static create(opts: ToolbarLinkStateOpts): ToolbarLinkState;
+    readonly opts: ToolbarLinkStateOpts;
     readonly root: ToolbarRootState;
-    constructor(opts: ToolbarLinkStateProps, root: ToolbarRootState);
+    constructor(opts: ToolbarLinkStateOpts, root: ToolbarRootState);
     onkeydown(e: BitsKeyboardEvent): void;
     readonly props: {
         readonly id: string;
@@ -100,14 +117,16 @@ declare class ToolbarLinkState {
         readonly onkeydown: (e: BitsKeyboardEvent) => void;
     };
 }
-type ToolbarButtonStateProps = WithRefProps<ReadableBoxedValues<{
+interface ToolbarButtonStateOpts extends WithRefOpts, ReadableBoxedValues<{
     disabled: boolean;
-}>>;
-declare class ToolbarButtonState {
+}> {
+}
+export declare class ToolbarButtonState {
     #private;
-    readonly opts: ToolbarButtonStateProps;
+    static create(opts: ToolbarButtonStateOpts): ToolbarButtonState;
+    readonly opts: ToolbarButtonStateOpts;
     readonly root: ToolbarRootState;
-    constructor(opts: ToolbarButtonStateProps, root: ToolbarRootState);
+    constructor(opts: ToolbarButtonStateOpts, root: ToolbarRootState);
     onkeydown(e: BitsKeyboardEvent): void;
     readonly props: {
         readonly id: string;
@@ -119,15 +138,4 @@ declare class ToolbarButtonState {
         readonly onkeydown: (e: BitsKeyboardEvent) => void;
     };
 }
-export declare function useToolbarRoot(props: ToolbarRootStateProps): ToolbarRootState;
-type InitToolbarGroupProps = WithRefProps<{
-    type: "single" | "multiple";
-    value: WritableBox<string> | WritableBox<string[]>;
-} & ReadableBoxedValues<{
-    disabled: boolean;
-}>>;
-export declare function useToolbarGroup(props: InitToolbarGroupProps): ToolbarGroupState;
-export declare function useToolbarGroupItem(props: ToolbarGroupItemStateProps): ToolbarGroupItemState;
-export declare function useToolbarButton(props: ToolbarButtonStateProps): ToolbarButtonState;
-export declare function useToolbarLink(props: ToolbarLinkStateProps): ToolbarLinkState;
 export {};

package/dist/bits/toolbar/toolbar.svelte.js

@@ -1,18 +1,23 @@
-import { attachRef } from "svelte-toolbelt";
+import { attachRef, } from "svelte-toolbelt";
 import { Context } from "runed";
 import { createBitsAttrs, getAriaChecked, getAriaPressed, getDataDisabled, getDataOrientation, getDisabled, } from "../../internal/attrs.js";
 import { kbd } from "../../internal/kbd.js";
-import { useRovingFocus, } from "../../internal/use-roving-focus.svelte.js";
+import { RovingFocusGroup } from "../../internal/roving-focus-group.js";
 export const toolbarAttrs = createBitsAttrs({
     component: "toolbar",
     parts: ["root", "item", "group", "group-item", "link", "button"],
 });
-class ToolbarRootState {
+const ToolbarRootContext = new Context("Toolbar.Root");
+const ToolbarGroupContext = new Context("Toolbar.Group");
+export class ToolbarRootState {
+    static create(opts) {
+        return ToolbarRootContext.set(new ToolbarRootState(opts));
+    }
     opts;
     rovingFocusGroup;
     constructor(opts) {
         this.opts = opts;
-        this.rovingFocusGroup = useRovingFocus({
+        this.rovingFocusGroup = new RovingFocusGroup({
             orientation: this.opts.orientation,
             loop: this.opts.loop,
             rootNode: this.opts.ref,
@@ -87,7 +92,21 @@ class ToolbarGroupMultipleState extends ToolbarGroupBaseState {
         }
     }
 }
-class ToolbarGroupItemState {
+export class ToolbarGroupState {
+    static create(opts) {
+        const { type, ...rest } = opts;
+        const rootState = ToolbarRootContext.get();
+        const groupState = type === "single"
+            ? new ToolbarGroupSingleState(rest, rootState)
+            : new ToolbarGroupMultipleState(rest, rootState);
+        return ToolbarGroupContext.set(groupState);
+    }
+}
+export class ToolbarGroupItemState {
+    static create(opts) {
+        const group = ToolbarGroupContext.get();
+        return new ToolbarGroupItemState(opts, group, group.root);
+    }
     opts;
     group;
     root;
@@ -149,7 +168,10 @@ class ToolbarGroupItemState {
         ...attachRef(this.opts.ref),
     }));
 }
-class ToolbarLinkState {
+export class ToolbarLinkState {
+    static create(opts) {
+        return new ToolbarLinkState(opts, ToolbarRootContext.get());
+    }
     opts;
     root;
     constructor(opts, root) {
@@ -184,7 +206,10 @@ class ToolbarLinkState {
         ...attachRef(this.opts.ref),
     }));
 }
-class ToolbarButtonState {
+export class ToolbarButtonState {
+    static create(opts) {
+        return new ToolbarButtonState(opts, ToolbarRootContext.get());
+    }
     opts;
     root;
     constructor(opts, root) {
@@ -227,26 +252,3 @@ class ToolbarButtonState {
 function getToggleItemDataState(condition) {
     return condition ? "on" : "off";
 }
-const ToolbarRootContext = new Context("Toolbar.Root");
-const ToolbarGroupContext = new Context("Toolbar.Group");
-export function useToolbarRoot(props) {
-    return ToolbarRootContext.set(new ToolbarRootState(props));
-}
-export function useToolbarGroup(props) {
-    const { type, ...rest } = props;
-    const rootState = ToolbarRootContext.get();
-    const groupState = type === "single"
-        ? new ToolbarGroupSingleState(rest, rootState)
-        : new ToolbarGroupMultipleState(rest, rootState);
-    return ToolbarGroupContext.set(groupState);
-}
-export function useToolbarGroupItem(props) {
-    const group = ToolbarGroupContext.get();
-    return new ToolbarGroupItemState(props, group, group.root);
-}
-export function useToolbarButton(props) {
-    return new ToolbarButtonState(props, ToolbarRootContext.get());
-}
-export function useToolbarLink(props) {
-    return new ToolbarLinkState(props, ToolbarRootContext.get());
-}

package/dist/bits/tooltip/components/tooltip-content-static.svelte

@@ -1,7 +1,7 @@
 <script lang="ts">
 	import { box, mergeProps } from "svelte-toolbelt";
 	import type { TooltipContentStaticProps } from "../types.js";
-	import { useTooltipContent } from "../tooltip.svelte.js";
+	import { TooltipContentState } from "../tooltip.svelte.js";
 	import { createId } from "../../../internal/create-id.js";
 	import PopperLayer from "../../utilities/popper-layer/popper-layer.svelte";
 	import { getFloatingContentCSSVars } from "../../../internal/floating-svelte/floating-utils.svelte.js";
@@ -21,7 +21,7 @@
 		...restProps
 	}: TooltipContentStaticProps = $props();
 
-	const contentState = useTooltipContent({
+	const contentState = TooltipContentState.create({
 		id: box.with(() => id),
 		ref: box.with(
 			() => ref,
@@ -67,7 +67,7 @@
 		{...contentState.popperProps}
 		tooltip={true}
 		isStatic
-		present={contentState.root.opts.open.current}
+		open={contentState.root.opts.open.current}
 		{id}
 		trapFocus={false}
 		loop={false}

package/dist/bits/tooltip/components/tooltip-content.svelte

@@ -1,7 +1,7 @@
 <script lang="ts">
 	import { box, mergeProps } from "svelte-toolbelt";
 	import type { TooltipContentProps } from "../types.js";
-	import { useTooltipContent } from "../tooltip.svelte.js";
+	import { TooltipContentState } from "../tooltip.svelte.js";
 	import { createId } from "../../../internal/create-id.js";
 	import PopperLayer from "../../utilities/popper-layer/popper-layer.svelte";
 	import { getFloatingContentCSSVars } from "../../../internal/floating-svelte/floating-utils.svelte.js";
@@ -29,7 +29,7 @@
 		...restProps
 	}: TooltipContentProps = $props();
 
-	const contentState = useTooltipContent({
+	const contentState = TooltipContentState.create({
 		id: box.with(() => id),
 		ref: box.with(
 			() => ref,
@@ -85,7 +85,7 @@
 	<PopperLayer
 		{...mergedProps}
 		{...contentState.popperProps}
-		present={contentState.root.opts.open.current}
+		open={contentState.root.opts.open.current}
 		{id}
 		trapFocus={false}
 		loop={false}

package/dist/bits/tooltip/components/tooltip-provider.svelte

@@ -1,7 +1,7 @@
 <script lang="ts">
 	import { box } from "svelte-toolbelt";
 	import type { TooltipProviderProps } from "../types.js";
-	import { useTooltipProvider } from "../tooltip.svelte.js";
+	import { TooltipProviderState } from "../tooltip.svelte.js";
 
 	let {
 		children,
@@ -13,7 +13,7 @@
 		skipDelayDuration = 300,
 	}: TooltipProviderProps = $props();
 
-	useTooltipProvider({
+	TooltipProviderState.create({
 		delayDuration: box.with(() => delayDuration),
 		disableCloseOnTriggerClick: box.with(() => disableCloseOnTriggerClick),
 		disableHoverableContent: box.with(() => disableHoverableContent),

package/dist/bits/tooltip/components/tooltip-trigger.svelte

@@ -1,7 +1,7 @@
 <script lang="ts">
 	import { box, mergeProps } from "svelte-toolbelt";
 	import type { TooltipTriggerProps } from "../types.js";
-	import { useTooltipTrigger } from "../tooltip.svelte.js";
+	import { TooltipTriggerState } from "../tooltip.svelte.js";
 	import { createId } from "../../../internal/create-id.js";
 	import FloatingLayerAnchor from "../../utilities/floating-layer/components/floating-layer-anchor.svelte";
 
@@ -17,7 +17,7 @@
 		...restProps
 	}: TooltipTriggerProps = $props();
 
-	const triggerState = useTooltipTrigger({
+	const triggerState = TooltipTriggerState.create({
 		id: box.with(() => id),
 		disabled: box.with(() => disabled ?? false),
 		ref: box.with(

package/dist/bits/tooltip/components/tooltip.svelte

@@ -1,13 +1,14 @@
 <script lang="ts">
 	import { box } from "svelte-toolbelt";
 	import type { TooltipRootProps } from "../types.js";
-	import { useTooltipRoot } from "../tooltip.svelte.js";
+	import { TooltipRootState } from "../tooltip.svelte.js";
 	import FloatingLayer from "../../utilities/floating-layer/components/floating-layer.svelte";
 	import { noop } from "../../../internal/noop.js";
 
 	let {
 		open = $bindable(false),
 		onOpenChange = noop,
+		onOpenChangeComplete = noop,
 		disabled,
 		delayDuration,
 		disableCloseOnTriggerClick,
@@ -16,7 +17,7 @@
 		children,
 	}: TooltipRootProps = $props();
 
-	useTooltipRoot({
+	TooltipRootState.create({
 		open: box.with(
 			() => open,
 			(v) => {
@@ -29,6 +30,7 @@
 		disableHoverableContent: box.with(() => disableHoverableContent),
 		ignoreNonKeyboardFocus: box.with(() => ignoreNonKeyboardFocus),
 		disabled: box.with(() => disabled),
+		onOpenChangeComplete: box.with(() => onOpenChangeComplete),
 	});
 </script>
 

package/dist/bits/tooltip/tooltip.svelte.d.ts

@@ -1,38 +1,42 @@
-import { DOMContext } from "svelte-toolbelt";
-import type { ReadableBoxedValues, WritableBoxedValues } from "../../internal/box.svelte.js";
-import type { WithRefProps } from "../../internal/types.js";
+import { DOMContext, type WritableBoxedValues, type ReadableBoxedValues } from "svelte-toolbelt";
+import type { OnChangeFn, WithRefOpts } from "../../internal/types.js";
 import type { FocusEventHandler, MouseEventHandler, PointerEventHandler } from "svelte/elements";
-export declare const tooltipAttrs: import("../../internal/attrs.js").BitsAttrs<readonly ["content", "trigger"]>;
-type TooltipProviderStateProps = ReadableBoxedValues<{
+export declare const tooltipAttrs: import("../../internal/attrs.js").CreateBitsAttrsReturn<readonly ["content", "trigger"]>;
+interface TooltipProviderStateOpts extends ReadableBoxedValues<{
     delayDuration: number;
     disableHoverableContent: boolean;
     disableCloseOnTriggerClick: boolean;
     disabled: boolean;
     ignoreNonKeyboardFocus: boolean;
     skipDelayDuration: number;
-}>;
-declare class TooltipProviderState {
+}> {
+}
+export declare class TooltipProviderState {
     #private;
-    readonly opts: TooltipProviderStateProps;
+    static create(opts: TooltipProviderStateOpts): TooltipProviderState;
+    readonly opts: TooltipProviderStateOpts;
     isOpenDelayed: boolean;
     isPointerInTransit: import("svelte-toolbelt").WritableBox<boolean>;
-    constructor(opts: TooltipProviderStateProps);
+    constructor(opts: TooltipProviderStateOpts);
     onOpen: (tooltip: TooltipRootState) => void;
     onClose: (tooltip: TooltipRootState) => void;
     isTooltipOpen: (tooltip: TooltipRootState) => boolean;
 }
-type TooltipRootStateProps = ReadableBoxedValues<{
+interface TooltipRootStateOpts extends ReadableBoxedValues<{
     delayDuration: number | undefined;
     disableHoverableContent: boolean | undefined;
     disableCloseOnTriggerClick: boolean | undefined;
     disabled: boolean | undefined;
     ignoreNonKeyboardFocus: boolean | undefined;
-}> & WritableBoxedValues<{
+    onOpenChangeComplete: OnChangeFn<boolean>;
+}>, WritableBoxedValues<{
     open: boolean;
-}>;
-declare class TooltipRootState {
+}> {
+}
+export declare class TooltipRootState {
     #private;
-    readonly opts: TooltipRootStateProps;
+    static create(opts: TooltipRootStateOpts): TooltipRootState;
+    readonly opts: TooltipRootStateOpts;
     readonly provider: TooltipProviderState;
     readonly delayDuration: number;
     readonly disableHoverableContent: boolean;
@@ -42,21 +46,23 @@ declare class TooltipRootState {
     contentNode: HTMLElement | null;
     triggerNode: HTMLElement | null;
     readonly stateAttr: string;
-    constructor(opts: TooltipRootStateProps, provider: TooltipProviderState);
+    constructor(opts: TooltipRootStateOpts, provider: TooltipProviderState);
     handleOpen: () => void;
     handleClose: () => void;
     onTriggerEnter: () => void;
     onTriggerLeave: () => void;
 }
-type TooltipTriggerStateProps = WithRefProps<ReadableBoxedValues<{
+interface TooltipTriggerStateOpts extends WithRefOpts, ReadableBoxedValues<{
     disabled: boolean;
-}>>;
-declare class TooltipTriggerState {
+}> {
+}
+export declare class TooltipTriggerState {
     #private;
-    readonly opts: TooltipTriggerStateProps;
+    static create(opts: TooltipTriggerStateOpts): TooltipTriggerState;
+    readonly opts: TooltipTriggerStateOpts;
     readonly root: TooltipRootState;
     domContext: DOMContext;
-    constructor(opts: TooltipTriggerStateProps, root: TooltipRootState);
+    constructor(opts: TooltipTriggerStateOpts, root: TooltipRootState);
     handlePointerUp: () => void;
     readonly props: {
         readonly id: string;
@@ -75,14 +81,16 @@ declare class TooltipTriggerState {
         readonly onclick: MouseEventHandler<HTMLElement>;
     };
 }
-type TooltipContentStateProps = WithRefProps & ReadableBoxedValues<{
+interface TooltipContentStateOpts extends WithRefOpts, ReadableBoxedValues<{
     onInteractOutside: (e: PointerEvent) => void;
     onEscapeKeydown: (e: KeyboardEvent) => void;
-}>;
-declare class TooltipContentState {
-    readonly opts: TooltipContentStateProps;
+}> {
+}
+export declare class TooltipContentState {
+    static create(opts: TooltipContentStateOpts): TooltipContentState;
+    readonly opts: TooltipContentStateOpts;
     readonly root: TooltipRootState;
-    constructor(opts: TooltipContentStateProps, root: TooltipRootState);
+    constructor(opts: TooltipContentStateOpts, root: TooltipRootState);
     onInteractOutside: (e: PointerEvent) => void;
     onEscapeKeydown: (e: KeyboardEvent) => void;
     onOpenAutoFocus: (e: Event) => void;
@@ -106,8 +114,4 @@ declare class TooltipContentState {
         onCloseAutoFocus: (e: Event) => void;
     };
 }
-export declare function useTooltipProvider(props: TooltipProviderStateProps): TooltipProviderState;
-export declare function useTooltipRoot(props: TooltipRootStateProps): TooltipRootState;
-export declare function useTooltipTrigger(props: TooltipTriggerStateProps): TooltipTriggerState;
-export declare function useTooltipContent(props: TooltipContentStateProps): TooltipContentState;
 export {};