@bridge-ui/vue 0.0.9 → 0.0.10

package/dist/Components/TimeRangeField/TimeRangeField.vue_vue_type_script_setup_true_lang.js

@@ -1,16 +1,18 @@
 import { useResolveMessage as e } from "../../Adapters/I18n/useI18nAdapter.js";
-import t from "../Icon/Icon.js";
-import n from "../FormField/FormField.js";
-import r from "../FieldOverlay/FieldOverlay.js";
-import { useTimeRangeField as i } from "./composables/useTimeRangeField.js";
-import a from "../TimeRangePicker/TimeRangePicker.js";
-import { Fragment as o, computed as s, createCommentVNode as c, createElementBlock as l, createElementVNode as u, createVNode as d, defineComponent as f, guardReactiveProps as p, isRef as m, mergeModels as h, mergeProps as g, normalizeClass as _, normalizeProps as v, openBlock as y, ref as b, unref as x, useModel as S, withCtx as C, withKeys as w, withModifiers as T } from "vue";
-import { isUndefined as E } from "es-toolkit/compat";
+import { presentSlotNames as t } from "../../Utils/slotOrProp.js";
+import n from "../Icon/Icon.js";
+import { FORM_FIELD_CHROME_SLOT_NAMES as r } from "../FormField/formField.types.js";
+import i from "../FormField/FormField.js";
+import a from "../FieldOverlay/FieldOverlay.js";
+import { useTimeRangeField as o } from "./composables/useTimeRangeField.js";
+import s from "../TimeRangePicker/TimeRangePicker.js";
+import { Fragment as c, computed as l, createCommentVNode as u, createElementBlock as d, createElementVNode as f, createSlots as p, createVNode as m, defineComponent as h, guardReactiveProps as g, isRef as _, mergeModels as v, mergeProps as y, normalizeClass as b, normalizeProps as x, openBlock as S, ref as C, renderList as w, renderSlot as T, unref as E, useModel as D, withCtx as O, withKeys as k, withModifiers as A } from "vue";
+import { isUndefined as j } from "es-toolkit/compat";
 //#region src/Components/TimeRangeField/TimeRangeField.vue?vue&type=script&setup=true&lang.ts
-var D = { class: "flex min-w-0 flex-1 items-center gap-1" }, O = ["aria-label"], k = /*@__PURE__*/ f({
+var M = { class: "flex min-w-0 flex-1 items-center gap-1" }, N = ["aria-label"], P = /*@__PURE__*/ h({
 	inheritAttrs: !1,
 	__name: "TimeRangeField",
-	props: /*@__PURE__*/ h({
+	props: /*@__PURE__*/ v({
 		ampm: { type: Boolean },
 		classes: {},
 		clearable: {
@@ -55,53 +57,56 @@ var D = { class: "flex min-w-0 flex-1 items-center gap-1" }, O = ["aria-label"],
 		modelValue: {},
 		modelModifiers: {}
 	}),
-	emits: /*@__PURE__*/ h([
+	emits: /*@__PURE__*/ v([
 		"change",
 		"clear",
 		"close",
 		"open"
 	], ["update:modelValue"]),
-	setup(f, { emit: h }) {
-		let k = S(f, "modelValue"), A = f, j = h, M = e(), N = b(A.defaultValue ?? null), P = s({
+	setup(h, { emit: v }) {
+		let P = D(h, "modelValue"), F = h, I = v, L = e(), R = C(F.defaultValue ?? null), z = l({
 			set: (e) => {
-				k.value = e, N.value = e;
+				P.value = e, R.value = e;
 			},
-			get: () => E(k.value) ? N.value : k.value
-		}), { open: F, overlay: I, timeOnly: L, formField: R, inputBind: z, clearBind: B, clearValue: V, modelValue: H, showFooter: U, pickerClass: W, clearIconSize: G, showClearIcon: K, handleOpenChange: q, handlePickerChange: J, handlePickerCancel: Y, overlayCustomProps: X, timeRangePickerCustomProps: Z } = i(A, P, j);
-		return (e, i) => (y(), l(o, null, [d(x(n), { field: x(R) }, {
-			default: C(() => [u("div", D, [u("input", v(p(x(z))), null, 16), x(K) ? (y(), l("span", g({ key: 0 }, x(B), {
-				onClick: i[0] ||= (...e) => x(V) && x(V)(...e),
-				"aria-label": x(M)("Clear"),
-				onKeydown: [i[1] ||= w(T((...e) => x(V) && x(V)(...e), ["prevent"]), ["enter"]), i[2] ||= w(T((...e) => x(V) && x(V)(...e), ["prevent"]), ["space"])]
-			}), [d(x(t), g({
+			get: () => j(P.value) ? R.value : P.value
+		}), { open: B, overlay: V, timeOnly: H, formField: U, inputBind: W, clearBind: G, clearValue: K, modelValue: q, showFooter: J, pickerClass: Y, clearIconSize: X, showClearIcon: Z, handleOpenChange: Q, handlePickerChange: $, handlePickerCancel: ee, overlayCustomProps: te, timeRangePickerCustomProps: ne } = o(F, z, I);
+		return (e, o) => (S(), d(c, null, [m(E(i), { field: E(U) }, p({
+			default: O(() => [f("div", M, [f("input", x(g(E(W))), null, 16), E(Z) ? (S(), d("span", y({ key: 0 }, E(G), {
+				onClick: o[0] ||= (...e) => E(K) && E(K)(...e),
+				"aria-label": E(L)("Clear"),
+				onKeydown: [o[1] ||= k(A((...e) => E(K) && E(K)(...e), ["prevent"]), ["enter"]), o[2] ||= k(A((...e) => E(K) && E(K)(...e), ["prevent"]), ["space"])]
+			}), [m(E(n), y({
 				icon: "clear",
-				size: x(G)
-			}, A.customProps?.clearIcon), null, 16, ["size"])], 16, O)) : c("", !0)])]),
-			_: 1
-		}, 8, ["field"]), d(x(r), {
-			modelValue: x(F),
-			"onUpdate:modelValue": [i[3] ||= (e) => m(F) ? F.value = e : null, x(q)],
-			overlay: x(I),
-			"custom-props": x(X)
+				size: E(X)
+			}, F.customProps?.clearIcon), null, 16, ["size"])], 16, N)) : u("", !0)])]),
+			_: 2
+		}, [w(E(t)(E(r), e.$slots), (t) => ({
+			name: t,
+			fn: O((n) => [T(e.$slots, t, x(g(n || {})))])
+		}))]), 1032, ["field"]), m(E(a), {
+			modelValue: E(B),
+			"onUpdate:modelValue": [o[3] ||= (e) => _(B) ? B.value = e : null, E(Q)],
+			overlay: E(V),
+			"custom-props": E(te)
 		}, {
-			default: C(() => [d(x(a), {
-				value: x(H),
-				class: _(x(W)),
-				ampm: x(L).ampm,
-				"show-footer": x(U),
-				"read-only": A.readonly,
-				"max-time": x(L).maxTime,
-				"min-time": x(L).minTime,
-				interval: x(L).interval,
-				"time-zone": x(L).timeZone,
-				onChange: x(J),
-				onCancel: x(Y),
-				"show-seconds": x(L).showSeconds,
-				color: x(R).merged.value.color,
-				disabled: x(R).isDisabled.value,
-				"disable-times": x(L).disableTimes,
-				rounded: x(R).merged.value.rounded,
-				"custom-props": x(Z)
+			default: O(() => [m(E(s), {
+				value: E(q),
+				class: b(E(Y)),
+				ampm: E(H).ampm,
+				"show-footer": E(J),
+				"read-only": F.readonly,
+				"max-time": E(H).maxTime,
+				"min-time": E(H).minTime,
+				interval: E(H).interval,
+				"time-zone": E(H).timeZone,
+				onChange: E($),
+				onCancel: E(ee),
+				"show-seconds": E(H).showSeconds,
+				color: E(U).merged.value.color,
+				disabled: E(U).isDisabled.value,
+				"disable-times": E(H).disableTimes,
+				rounded: E(U).merged.value.rounded,
+				"custom-props": E(ne)
 			}, null, 8, [
 				"value",
 				"class",
@@ -131,4 +136,4 @@ var D = { class: "flex min-w-0 flex-1 items-center gap-1" }, O = ["aria-label"],
 	}
 });
 //#endregion
-export { k as default };
+export { P as default };

package/dist/Components/TimeRangeField/composables/useTimeRangeField.d.ts

@@ -710,15 +710,25 @@ export declare function useTimeRangeField(props: TimeRangeFieldOwnProps, model:
     handlePickerChange: (next: null | TimeRangeValue) => void;
     handlePickerCancel: () => void;
     overlayCustomProps: import('vue').ComputedRef<{
-        modal: Partial<Pick<import('../../Modal').ModalOwnProps, "size" | "classes" | "customProps" | "blur" | "transition" | "align">> | undefined;
-        drawer: Partial<Pick<import('../../Drawer').DrawerOwnProps, "size" | "classes" | "customProps" | "blur" | "placement" | "transition">> | undefined;
+        modal: Partial<import('../../Modal').ModalOwnProps> | undefined;
+        drawer: Partial<import('../../Drawer').DrawerOwnProps> | undefined;
         menu: {
+            anchorEl: null | HTMLElement;
             classes?: import('../../Menu').MenuClasses;
+            closeOnClickAway?: boolean;
+            closeOnEscape?: boolean;
             customProps?: import('../../Menu').MenuCustomProps;
+            disableAutoFocus?: boolean;
+            disableScrollLock?: boolean;
+            keepMounted?: boolean;
+            offset?: number;
+            onShowChange?: (show: boolean) => void;
+            persistent?: boolean;
+            placement: import('@floating-ui/utils').Placement;
             rounded?: import('@bridge-ui/core').MergeProps<import('@bridge-ui/core').MenuRounded, import('../../Menu').MenuRoundedOverrides>;
             shadow?: import('@bridge-ui/core').MergeProps<import('@bridge-ui/core').MenuShadow, import('../../Menu').MenuShadowOverrides>;
-            placement: import('@floating-ui/utils').Placement;
-            anchorEl: HTMLElement | null;
+            strategy?: import('@bridge-ui/core').PositionStrategy;
+            teleportTo?: false | string;
         };
     }>;
     timeRangePickerCustomProps: import('vue').ComputedRef<import('../../TimeRangePicker').TimeRangePickerCustomProps | undefined>;

package/dist/Components/TimeRangeField/timeRangeField.types.d.ts

@@ -24,19 +24,19 @@ export interface TimeRangeFieldCustomProps extends FormFieldCustomProps {
      *
      * @default undefined
      */
-    drawer?: Partial<Pick<DrawerOwnProps, "blur" | "size" | "classes" | "placement" | "transition" | "customProps">>;
+    drawer?: Partial<DrawerOwnProps>;
     /**
      * Props forwarded to the floating `Menu` when overlay resolves to menu.
      *
      * @default undefined
      */
-    menu?: Partial<Pick<MenuOwnProps, "shadow" | "classes" | "rounded" | "placement" | "customProps">>;
+    menu?: Partial<MenuOwnProps>;
     /**
      * Props forwarded to the nested `Modal` when overlay resolves to modal.
      *
      * @default undefined
      */
-    modal?: Partial<Pick<ModalOwnProps, "blur" | "size" | "align" | "classes" | "transition" | "customProps">>;
+    modal?: Partial<ModalOwnProps>;
     /**
      * Props forwarded to the nested `TimeRangePicker`.
      *

package/dist/Components/Tooltip/Tooltip.vue_vue_type_script_setup_true_lang.js

@@ -1,8 +1,8 @@
-import { hasNamedSlot as e, resolveNamedSlot as t, resolveSlotOrProp as n } from "../../Utils/slotOrProp.js";
-import { useTooltip as r } from "./composables/useTooltip.js";
-import { Fragment as i, Teleport as a, computed as o, createBlock as s, createCommentVNode as c, createElementBlock as l, createElementVNode as u, defineComponent as d, mergeModels as f, mergeProps as p, normalizeProps as m, openBlock as h, resolveDynamicComponent as g, unref as _, useModel as v, useSlots as y } from "vue";
+import { hasNamedSlot as e, isPropPresent as t } from "../../Utils/slotOrProp.js";
+import { useTooltip as n } from "./composables/useTooltip.js";
+import { Fragment as r, Teleport as i, computed as a, createBlock as o, createCommentVNode as s, createElementBlock as c, createElementVNode as l, createTextVNode as u, defineComponent as d, mergeModels as f, mergeProps as p, normalizeProps as m, openBlock as h, renderSlot as g, toDisplayString as _, unref as v, useModel as y, useSlots as b } from "vue";
 //#region src/Components/Tooltip/Tooltip.vue?vue&type=script&setup=true&lang.ts
-var b = /*@__PURE__*/ d({
+var x = /*@__PURE__*/ d({
 	inheritAttrs: !1,
 	__name: "Tooltip",
 	props: /*@__PURE__*/ f({
@@ -40,7 +40,7 @@ var b = /*@__PURE__*/ d({
 	}),
 	emits: /*@__PURE__*/ f(["show-change"], ["update:modelValue"]),
 	setup(d, { emit: f }) {
-		let b = y(), x = f, S = d, C = v(d, "modelValue"), { merged: w, mounted: T, rootBind: E, arrowBind: D, triggerBind: O, contentBind: k, setArrowRef: A, setTriggerRef: j, setContentRef: M } = r(S, {
+		let x = b(), S = f, C = d, w = y(d, "modelValue"), { merged: T, mounted: E, rootBind: D, arrowBind: O, triggerBind: k, contentBind: A, setArrowRef: j, setTriggerRef: M, setContentRef: N } = n(C, {
 			offset: 8,
 			size: "md",
 			arrow: !0,
@@ -52,22 +52,22 @@ var b = /*@__PURE__*/ d({
 			strategy: "fixed",
 			teleportTo: "body"
 		}, {
-			show: C,
+			show: w,
 			onShowChange: (e) => {
-				S.onShowChange?.(e), x("show-change", e);
+				C.onShowChange?.(e), S("show-change", e);
 			}
-		}), N = o(() => e(b, "trigger")), P = o(() => n(b, "default", w.value.content)), F = o(() => w.value.teleportTo === !1), I = o(() => w.value.teleportTo === !1 ? "body" : w.value.teleportTo);
-		return (e, n) => (h(), l(i, null, [N.value ? (h(), l("div", m(p({ key: 0 }, _(E))), [u("div", p({ ref: _(j) }, _(O)), [(h(), s(g(_(t)(_(b), "trigger"))))], 16)], 16)) : c("", !0), (h(), s(a, {
-			to: I.value,
-			disabled: F.value
-		}, [_(T) ? (h(), l("div", p({
+		}), P = a(() => T.value.teleportTo === !1), F = a(() => T.value.teleportTo === !1 ? "body" : T.value.teleportTo);
+		return (n, a) => (h(), c(r, null, [v(e)(v(x), "trigger") ? (h(), c("div", m(p({ key: 0 }, v(D))), [l("div", p({ ref: v(M) }, v(k)), [g(n.$slots, "trigger")], 16)], 16)) : s("", !0), (h(), o(i, {
+			to: F.value,
+			disabled: P.value
+		}, [v(E) ? (h(), c("div", p({
 			key: 0,
-			ref: _(M)
-		}, _(k)), [(h(), s(g(P.value))), _(D) ? (h(), l("div", p({
-			key: 0,
-			ref: _(A)
-		}, _(D)), null, 16)) : c("", !0)], 16)) : c("", !0)], 8, ["to", "disabled"]))], 64));
+			ref: v(N)
+		}, v(A)), [v(e)(v(x), "default") ? g(n.$slots, "default", {}, void 0, void 0, 0) : v(t)(v(T).content) ? (h(), c(r, { key: 1 }, [u(_(v(T).content), 1)], 64)) : s("", !0), v(O) ? (h(), c("div", p({
+			key: 2,
+			ref: v(j)
+		}, v(O)), null, 16)) : s("", !0)], 16)) : s("", !0)], 8, ["to", "disabled"]))], 64));
 	}
 });
 //#endregion
-export { b as default };
+export { x as default };

package/dist/Utils/index.d.ts

@@ -49,7 +49,7 @@ export declare function resolveFieldAdornmentIconSize(fieldSize?: keyof FormFiel
  * Resolves a Vue template ref callback value to an HTMLElement.
  */
 export declare function resolveVnodeRefElement(element: null | Element | ComponentPublicInstance): null | HTMLElement;
-export { hasNamedSlot, hasSlotOrProp, isPropPresent, resolveNamedSlot, resolveSlotOrProp, } from './slotOrProp';
+export { hasNamedSlot, hasSlotOrProp, isPropPresent, presentSlotNames, RenderFn, } from './slotOrProp';
 export { useBreakpoint } from './useBreakpoint';
 export type { UseBreakpointOptions } from './useBreakpoint';
 export { useHoldRepeat } from './useHoldRepeat';

package/dist/Utils/index.js

@@ -1,5 +1,5 @@
 import { useBridgeUI as e } from "../Provider/useBridgeUI.js";
-import { hasNamedSlot as t, hasSlotOrProp as n, isPropPresent as r, resolveNamedSlot as i, resolveSlotOrProp as a } from "./slotOrProp.js";
+import { RenderFn as t, hasNamedSlot as n, hasSlotOrProp as r, isPropPresent as i, presentSlotNames as a } from "./slotOrProp.js";
 import { useBreakpoint as o } from "./useBreakpoint.js";
 import { useHoldRepeat as s } from "./useHoldRepeat.js";
 import { computed as c, defineComponent as l, toValue as u, unref as d } from "vue";
@@ -56,4 +56,4 @@ function w(e) {
 	return null;
 }
 //#endregion
-export { v as defineHeadlessComponent, t as hasNamedSlot, n as hasSlotOrProp, r as isPropPresent, b as mergeNestedComponentProps, y as mergePartBind, C as resolveFieldAdornmentIconSize, i as resolveNamedSlot, a as resolveSlotOrProp, w as resolveVnodeRefElement, o as useBreakpoint, x as useBridgeUIComponent, S as useBridgeUIMergedRegistryClasses, s as useHoldRepeat };
+export { t as RenderFn, v as defineHeadlessComponent, n as hasNamedSlot, r as hasSlotOrProp, i as isPropPresent, b as mergeNestedComponentProps, y as mergePartBind, a as presentSlotNames, C as resolveFieldAdornmentIconSize, w as resolveVnodeRefElement, o as useBreakpoint, x as useBridgeUIComponent, S as useBridgeUIMergedRegistryClasses, s as useHoldRepeat };

package/dist/Utils/slotOrProp.d.ts

@@ -1,4 +1,4 @@
-import { Slot, Slots, VNodeChild } from 'vue';
+import { PropType, Slots } from 'vue';
 type VueSlots = Slots | undefined | Readonly<Slots>;
 /**
  * Whether a prop value is considered present for fallback rendering.
@@ -13,16 +13,25 @@ export declare function hasNamedSlot(slots: VueSlots, name: string): boolean;
  */
 export declare function hasSlotOrProp(slots: VueSlots, name: string, prop: unknown): boolean;
 /**
- * Slot render function for `<component :is="resolveNamedSlot(slots, name)" />`.
- * Returns the slot function itself so `:is` keeps a stable identity across parent
- * re-renders (wrapping in a new render function would remount slot content and drop
- * native states such as `:hover` / `:active` during hold-repeat).
+ * Slot names from `names` that were actually passed.
+ * Use when forwarding chrome slots so empty outlets are not treated as present.
  */
-export declare function resolveNamedSlot(slots: VueSlots, name: string): Slot | undefined;
+export declare function presentSlotNames<T extends string>(names: ReadonlyArray<T>, slots: VueSlots): T[];
 /**
- * Render target for `<component :is="resolveSlotOrProp(slots, name, fallback)" />`.
- * Returns the named slot function when present; otherwise a render function for the
- * fallback prop.
+ * Stable host for programmatic render functions (e.g. Tabs `items` API).
+ * Prefer native `<slot>` everywhere else.
  */
-export declare function resolveSlotOrProp(slots: VueSlots, name: string, fallback?: null | number | string): Slot | (() => null | VNodeChild);
-export type { Slot };
+export declare const RenderFn: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    fn: {
+        default: undefined;
+        type: PropType<undefined | (() => unknown)>;
+    };
+}>, () => {} | null, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    fn: {
+        default: undefined;
+        type: PropType<undefined | (() => unknown)>;
+    };
+}>> & Readonly<{}>, {
+    fn: (() => unknown) | undefined;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export {};

package/dist/Utils/slotOrProp.js

@@ -1,23 +1,27 @@
-import { get as e, isEmpty as t, isNil as n, isString as r } from "es-toolkit/compat";
+import { defineComponent as e } from "vue";
+import { get as t, isEmpty as n, isNil as r, isString as i } from "es-toolkit/compat";
 //#region src/Utils/slotOrProp.ts
-function i(e) {
-	return n(e) ? !1 : !r(e) || !t(e);
+function a(e) {
+	return r(e) ? !1 : !i(e) || !n(e);
 }
-function a(t, r) {
-	return !n(e(t, r));
+function o(e, n) {
+	return !r(t(e, n));
 }
-function o(e, t, n) {
-	return a(e, t) || i(n);
+function s(e, t, n) {
+	return o(e, t) || a(n);
 }
-function s(t, n) {
-	return e(t, n);
-}
-function c(t, r, a) {
-	let o = e(t, r);
-	if (!n(o)) return o;
-	if (!i(a)) return () => null;
-	let s = String(a);
-	return () => s;
+function c(e, t) {
+	return e.filter((e) => o(t, e));
 }
+var l = e({
+	name: "RenderFn",
+	setup(e) {
+		return () => e.fn?.() ?? null;
+	},
+	props: { fn: {
+		default: void 0,
+		type: Function
+	} }
+});
 //#endregion
-export { a as hasNamedSlot, o as hasSlotOrProp, i as isPropPresent, s as resolveNamedSlot, c as resolveSlotOrProp };
+export { l as RenderFn, o as hasNamedSlot, s as hasSlotOrProp, a as isPropPresent, c as presentSlotNames };

package/dist/Utils/useBreakpoint.d.ts

@@ -11,9 +11,5 @@ export type UseBreakpointOptions = BreakpointObserverOptions;
  * `global.breakpoints`. Composable options win when passed.
  *
  * On the server (and before mount), `mobile` is `true` at width `0`.
- *
- * @example
- * const breakpoint = useBreakpoint();
- * // :align="breakpoint.mobile ? 'bottom-center' : 'middle-center'"
  */
 export declare function useBreakpoint(options?: MaybeRefOrGetter<undefined | UseBreakpointOptions>): BreakpointSnapshot;

package/dist/index.d.ts

@@ -2,6 +2,10 @@ export { setDateAdapterForTests, useDateAdapter, useDateAdapterContext, } from '
 export { setI18nAdapterForTests, useI18nAdapter, useResolveMessage, } from './Adapters/I18n';
 export { setIconAdapterForTests, useIconAdapter } from './Adapters/Icon';
 export type { IconElement, IconSource, SemanticIconName, } from './Adapters/Icon';
+export { ACCORDION_INJECTION_KEY, Accordion, useAccordion, } from './Components/Accordion';
+export type { AccordionClasses, AccordionColorOverrides, AccordionContextValue, AccordionCustomProps, AccordionEmits, AccordionOwnProps, AccordionProps, AccordionSizeOverrides, AccordionSlots, AccordionTokenClasses, AccordionVariantOverrides, } from './Components/Accordion';
+export { AccordionItem, useAccordionItem } from './Components/AccordionItem';
+export type { AccordionItemClasses, AccordionItemCustomProps, AccordionItemOwnProps, AccordionItemProps, AccordionItemSlots, } from './Components/AccordionItem';
 export { Alert, useAlert } from './Components/Alert';
 export type { AlertClasses, AlertColorOverrides, AlertPaddingOverrides, AlertProps, AlertRoundedOverrides, AlertShadowOverrides, AlertSlots, AlertVariantOverrides, } from './Components/Alert';
 export { Autocomplete, AutocompleteOption } from './Components/Autocomplete';
@@ -12,6 +16,10 @@ export { Badge, useBadge } from './Components/Badge';
 export type { BadgeClasses, BadgeColorOverrides, BadgeDensityOverrides, BadgeOwnProps, BadgeProps, BadgeRoundedOverrides, BadgeSizeOverrides, BadgeSlots, BadgeVariantOverrides, } from './Components/Badge';
 export { BaseField, useBaseField } from './Components/BaseField';
 export type { BaseFieldClasses, BaseFieldCustomProps, BaseFieldOptions, BaseFieldOwnProps, BaseFieldProps, BaseFieldSizeOverrides, BaseFieldSlots, UseBaseFieldReturn, } from './Components/BaseField';
+export { Breadcrumb, useBreadcrumb } from './Components/Breadcrumb';
+export type { BreadcrumbClasses, BreadcrumbContextValue, BreadcrumbCustomProps, BreadcrumbItemData, BreadcrumbOwnProps, BreadcrumbProps, BreadcrumbSizeOverrides, BreadcrumbSlots, } from './Components/Breadcrumb';
+export { BreadcrumbItem, useBreadcrumbItem } from './Components/BreadcrumbItem';
+export type { BreadcrumbItemClasses, BreadcrumbItemCustomProps, BreadcrumbItemOwnProps, BreadcrumbItemProps, BreadcrumbItemSlots, } from './Components/BreadcrumbItem';
 export { Button, useButton } from './Components/Button';
 export type { ButtonClasses, ButtonColorOverrides, ButtonDensityOverrides, ButtonProps, ButtonRoundedOverrides, ButtonSizeOverrides, ButtonSlots, ButtonVariantOverrides, } from './Components/Button';
 export { Calendar, useCalendar } from './Components/Calendar';