@bridge-ui/vue 0.0.1-beta.7 → 0.0.1

package/dist/Actions/BridgeUIHosts.vue.d.ts

@@ -1,11 +1,12 @@
 import { BridgeUIHostsProps } from './bridgeUIHosts.types';
-declare var __VLS_20: {};
+declare var __VLS_26: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_20) => any;
+    default?: (props: typeof __VLS_26) => any;
 };
 declare const __VLS_base: import('vue').DefineComponent<BridgeUIHostsProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<BridgeUIHostsProps> & Readonly<{}>, {
     dialog: import('./Dialog').BridgeDialogHostProps;
     modal: import('./Modal').BridgeModalHostProps;
+    drawer: import('./Drawer').BridgeDrawerHostProps;
     snackbar: import('./Snackbar').BridgeSnackbarHostProps;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

package/dist/Actions/BridgeUIHosts.vue_vue_type_script_setup_true_lang.js

@@ -1,20 +1,25 @@
 import e from "./Dialog/BridgeDialogHost.js";
-import t from "./Modal/BridgeModalHost.js";
-import n from "./Snackbar/BridgeSnackbarHost.js";
-import { createBlock as r, createVNode as i, defineComponent as a, guardReactiveProps as o, normalizeProps as s, openBlock as c, renderSlot as l, unref as u, withCtx as d } from "vue";
+import t from "./Drawer/BridgeDrawerHost.js";
+import n from "./Modal/BridgeModalHost.js";
+import r from "./Snackbar/BridgeSnackbarHost.js";
+import { createBlock as i, createVNode as a, defineComponent as o, guardReactiveProps as s, normalizeProps as c, openBlock as l, renderSlot as u, unref as d, withCtx as f } from "vue";
 //#region src/Actions/BridgeUIHosts.vue?vue&type=script&setup=true&lang.ts
-var f = /* @__PURE__ */ a({
+var p = /* @__PURE__ */ o({
 	__name: "BridgeUIHosts",
 	props: {
 		dialog: { default: () => ({}) },
+		drawer: { default: () => ({}) },
 		modal: { default: () => ({}) },
 		snackbar: { default: () => ({}) }
 	},
-	setup(a) {
-		return (f, p) => (c(), r(u(t), s(o(a.modal)), {
-			default: d(() => [i(u(e), s(o(a.dialog)), {
-				default: d(() => [i(u(n), s(o(a.snackbar)), {
-					default: d(() => [l(f.$slots, "default")]),
+	setup(o) {
+		return (p, m) => (l(), i(d(n), c(s(o.modal)), {
+			default: f(() => [a(d(t), c(s(o.drawer)), {
+				default: f(() => [a(d(e), c(s(o.dialog)), {
+					default: f(() => [a(d(r), c(s(o.snackbar)), {
+						default: f(() => [u(p.$slots, "default")]),
+						_: 3
+					}, 16)]),
 					_: 3
 				}, 16)]),
 				_: 3
@@ -24,4 +29,4 @@ var f = /* @__PURE__ */ a({
 	}
 });
 //#endregion
-export { f as default };
+export { p as default };

package/dist/Actions/Drawer/BridgeDrawerHost.js

@@ -0,0 +1,5 @@
+import e from "./BridgeDrawerHost.vue_vue_type_script_setup_true_lang.js";
+//#region src/Actions/Drawer/BridgeDrawerHost.vue
+var t = e;
+//#endregion
+export { t as default };

package/dist/Actions/Drawer/BridgeDrawerHost.vue.d.ts

@@ -0,0 +1,14 @@
+import { BridgeDrawerHostProps } from './bridgeDrawer.types';
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<BridgeDrawerHostProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<BridgeDrawerHostProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Actions/Drawer/BridgeDrawerHost.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,35 @@
+import e from "../../Components/Drawer/Drawer.js";
+import { BRIDGE_DRAWER_INJECTION_KEY as t } from "./bridgeDrawerInjectionKey.js";
+import { createBridgeDrawerApi as n } from "./createBridgeDrawerApi.js";
+import { Fragment as r, computed as i, createBlock as a, createElementBlock as o, defineComponent as s, inject as c, mergeProps as l, openBlock as u, provide as d, renderList as f, renderSlot as p, resolveDynamicComponent as m, unref as h, withCtx as g } from "vue";
+import { completeLayerHide as _, invokeLayerDismiss as v, mergeLayerShellProps as y } from "@bridge-ui/core";
+//#region src/Actions/Drawer/BridgeDrawerHost.vue?vue&type=script&setup=true&lang.ts
+var b = "[Bridge UI] Nested <BridgeDrawerHost /> detected. useDrawerAction() will target the nearest host only. Remove the extra host.", x = /* @__PURE__ */ s({
+	__name: "BridgeDrawerHost",
+	props: { drawer: {} },
+	setup(s) {
+		let x = s;
+		c(t, null) && process.env.NODE_ENV !== "production" && console.warn(b);
+		let S = n(), C = i(() => S.entries.value);
+		return d(t, S), (t, n) => (u(), o(r, null, [p(t.$slots, "default"), (u(!0), o(r, null, f(C.value, (t) => (u(), a(h(e), l({
+			key: t.id,
+			"stack-id": t.id,
+			"model-value": t.show,
+			"onUpdate:modelValue": (e) => h(S).syncShow(t.id, e)
+		}, { ref_for: !0 }, h(y)(x.drawer, t.drawer), {
+			onClose: (e) => h(v)(h(S).entries.value, t.id),
+			onShowChange: (e) => h(_)(h(S).entries.value, t.id, e, h(S).removeEntry)
+		}), {
+			default: g(() => [(u(), a(m(t.component), l({ ref_for: !0 }, t.props), null, 16))]),
+			_: 2
+		}, 1040, [
+			"stack-id",
+			"model-value",
+			"onUpdate:modelValue",
+			"onClose",
+			"onShowChange"
+		]))), 128))], 64));
+	}
+});
+//#endregion
+export { x as default };

package/dist/Actions/Drawer/bridgeDrawer.types.d.ts

@@ -0,0 +1,44 @@
+import { LayerId } from '@bridge-ui/core';
+import { Component, Ref } from 'vue';
+import { DrawerOwnProps } from '../../Components/Drawer/drawer.types';
+export type BridgeDrawerShellProps = Partial<Omit<DrawerOwnProps, "stackId">>;
+export type BridgeDrawerHostProps = {
+    /**
+     * Default shell options merged into every drawer opened via `useDrawerAction()`.
+     * Per-call `open({ drawer })` overrides these.
+     */
+    drawer?: BridgeDrawerShellProps;
+};
+export type BridgeDrawerEntry = {
+    component: Component;
+    drawer?: Partial<DrawerOwnProps>;
+    id: LayerId;
+    onClose?: () => void;
+    onClosed?: () => void;
+    props?: Record<string, unknown>;
+    show: boolean;
+};
+export type BridgeDrawerOpenOptions<TProps = Record<string, unknown>> = {
+    component: Component;
+    drawer?: Partial<DrawerOwnProps>;
+    onClose?: () => void;
+    onClosed?: () => void;
+    props?: TProps;
+};
+export type BridgeDrawerUpdateOptions = {
+    drawer?: Partial<DrawerOwnProps>;
+    props?: Record<string, unknown>;
+};
+export type BridgeDrawerController = {
+    close: (id: LayerId) => void;
+    closeTop: () => void;
+    entries: Ref<BridgeDrawerEntry[]>;
+    isOpen: (id: LayerId) => boolean;
+    open: <TProps = Record<string, unknown>>(options: BridgeDrawerOpenOptions<TProps>) => LayerId;
+    removeEntry: (id: LayerId) => void;
+    syncShow: (id: LayerId, show: boolean) => void;
+    update: (id: LayerId, options: BridgeDrawerUpdateOptions) => void;
+};
+export type BridgeDrawerApi = Omit<BridgeDrawerController, "entries" | "syncShow" | "removeEntry"> & {
+    stackSize: number;
+};

package/dist/Actions/Drawer/bridgeDrawerInjectionKey.d.ts

@@ -0,0 +1,3 @@
+import { InjectionKey } from 'vue';
+import { BridgeDrawerController } from './bridgeDrawer.types';
+export declare const BRIDGE_DRAWER_INJECTION_KEY: InjectionKey<BridgeDrawerController>;

package/dist/Actions/Drawer/bridgeDrawerInjectionKey.js

@@ -0,0 +1,4 @@
+//#region src/Actions/Drawer/bridgeDrawerInjectionKey.ts
+var e = Symbol.for("@bridge-ui/vue/bridge-drawer");
+//#endregion
+export { e as BRIDGE_DRAWER_INJECTION_KEY };

package/dist/Actions/Drawer/createBridgeDrawerApi.d.ts

@@ -0,0 +1,2 @@
+import { BridgeDrawerController } from './bridgeDrawer.types';
+export declare function createBridgeDrawerApi(): BridgeDrawerController;

package/dist/Actions/Drawer/createBridgeDrawerApi.js

@@ -0,0 +1,49 @@
+import { markRaw as e, shallowRef as t } from "vue";
+import { closeLayer as n, closeTopLayer as r, createLayerId as i, createOpenLayerEntry as a, isLayerMounted as o, removeLayer as s, syncLayerShow as c, updateLayer as l } from "@bridge-ui/core";
+//#region src/Actions/Drawer/createBridgeDrawerApi.ts
+function u(t, n) {
+	return a(t, {
+		props: n.props,
+		drawer: n.drawer,
+		onClose: n.onClose,
+		onClosed: n.onClosed,
+		component: e(n.component)
+	});
+}
+function d() {
+	let e = t([]);
+	function a(t) {
+		let n = i(), r = u(n, t);
+		return e.value = [...e.value, r], n;
+	}
+	function d(t) {
+		e.value = n(e.value, t);
+	}
+	function f() {
+		e.value = r(e.value);
+	}
+	function p(t) {
+		return o(e.value, t);
+	}
+	function m(t) {
+		e.value = s(e.value, t);
+	}
+	function h(t, n) {
+		e.value = l(e.value, t, n);
+	}
+	function g(t, n) {
+		e.value = c(e.value, t, n);
+	}
+	return {
+		open: a,
+		close: d,
+		isOpen: p,
+		update: h,
+		entries: e,
+		closeTop: f,
+		syncShow: g,
+		removeEntry: m
+	};
+}
+//#endregion
+export { d as createBridgeDrawerApi };

package/dist/Actions/Drawer/index.d.ts

@@ -0,0 +1,3 @@
+export type { BridgeDrawerApi, BridgeDrawerController, BridgeDrawerEntry, BridgeDrawerHostProps, BridgeDrawerOpenOptions, BridgeDrawerShellProps, BridgeDrawerUpdateOptions, } from './bridgeDrawer.types';
+export { default as BridgeDrawerHost } from './BridgeDrawerHost.vue';
+export { BridgeDrawerHostMissingError, useDrawerAction, } from './useDrawerAction';

package/dist/Actions/Drawer/index.js

@@ -0,0 +1,3 @@
+import e from "./BridgeDrawerHost.js";
+import { BridgeDrawerHostMissingError as t, useDrawerAction as n } from "./useDrawerAction.js";
+export { e as BridgeDrawerHost, t as BridgeDrawerHostMissingError, n as useDrawerAction };

package/dist/Actions/Drawer/useDrawerAction.d.ts

@@ -0,0 +1,5 @@
+import { BridgeDrawerApi } from './bridgeDrawer.types';
+export declare class BridgeDrawerHostMissingError extends Error {
+    constructor();
+}
+export declare function useDrawerAction(): BridgeDrawerApi;

package/dist/Actions/Drawer/useDrawerAction.js

@@ -0,0 +1,26 @@
+import { BRIDGE_DRAWER_INJECTION_KEY as e } from "./bridgeDrawerInjectionKey.js";
+import { computed as t, inject as n } from "vue";
+import { getLayerCount as r } from "@bridge-ui/core";
+//#region src/Actions/Drawer/useDrawerAction.ts
+var i = class extends Error {
+	constructor() {
+		super("useDrawerAction() requires <BridgeDrawerHost /> in the app tree."), this.name = "BridgeDrawerHostMissingError";
+	}
+};
+function a() {
+	let a = n(e, null);
+	if (!a) throw new i();
+	let o = t(() => r(a.entries.value));
+	return {
+		open: a.open,
+		close: a.close,
+		isOpen: a.isOpen,
+		update: a.update,
+		closeTop: a.closeTop,
+		get stackSize() {
+			return o.value;
+		}
+	};
+}
+//#endregion
+export { i as BridgeDrawerHostMissingError, a as useDrawerAction };

package/dist/Actions/bridgeUIHosts.types.d.ts

@@ -1,4 +1,5 @@
 import { BridgeDialogHostProps } from './Dialog/bridgeDialog.types';
+import { BridgeDrawerHostProps } from './Drawer/bridgeDrawer.types';
 import { BridgeModalHostProps } from './Modal/bridgeModal.types';
 import { BridgeSnackbarHostProps } from './Snackbar/bridgeSnackbar.types';
 export type BridgeUIHostsProps = {
@@ -6,6 +7,10 @@ export type BridgeUIHostsProps = {
      * Props forwarded to {@link BridgeDialogHost}.
      */
     dialog?: BridgeDialogHostProps;
+    /**
+     * Props forwarded to {@link BridgeDrawerHost}.
+     */
+    drawer?: BridgeDrawerHostProps;
     /**
      * Props forwarded to {@link BridgeModalHost}.
      */

package/dist/Actions/index.d.ts

@@ -2,6 +2,8 @@ export type { BridgeUIHostsProps } from './bridgeUIHosts.types';
 export { default as BridgeUIHosts } from './BridgeUIHosts.vue';
 export { BridgeDialogHost, BridgeDialogHostMissingError, useDialogAction, } from './Dialog';
 export type { BridgeDialogActionProps, BridgeDialogApi, BridgeDialogEntry, BridgeDialogHostProps, BridgeDialogOpenOptions, BridgeDialogShellProps, BridgeDialogUpdateOptions, DialogAction, DialogActions, } from './Dialog';
+export { BridgeDrawerHost, BridgeDrawerHostMissingError, useDrawerAction, } from './Drawer';
+export type { BridgeDrawerApi, BridgeDrawerController, BridgeDrawerEntry, BridgeDrawerHostProps, BridgeDrawerOpenOptions, BridgeDrawerShellProps, BridgeDrawerUpdateOptions, } from './Drawer';
 export { BridgeModalHost, BridgeModalHostMissingError, useModalAction, } from './Modal';
 export type { BridgeModalApi, BridgeModalController, BridgeModalEntry, BridgeModalHostProps, BridgeModalOpenOptions, BridgeModalShellProps, BridgeModalUpdateOptions, } from './Modal';
 export { BridgeSnackbarHost, BridgeSnackbarHostMissingError, useSnackbarAction, } from './Snackbar';

package/dist/Actions/index.js

@@ -1,8 +1,10 @@
 import e from "./Dialog/BridgeDialogHost.js";
 import { BridgeDialogHostMissingError as t, useDialogAction as n } from "./Dialog/useDialogAction.js";
-import r from "./Modal/BridgeModalHost.js";
-import { BridgeModalHostMissingError as i, useModalAction as a } from "./Modal/useModalAction.js";
-import o from "./Snackbar/BridgeSnackbarHost.js";
-import { BridgeSnackbarHostMissingError as s, useSnackbarAction as c } from "./Snackbar/useSnackbarAction.js";
-import l from "./BridgeUIHosts.js";
-export { e as BridgeDialogHost, t as BridgeDialogHostMissingError, r as BridgeModalHost, i as BridgeModalHostMissingError, o as BridgeSnackbarHost, s as BridgeSnackbarHostMissingError, l as BridgeUIHosts, n as useDialogAction, a as useModalAction, c as useSnackbarAction };
+import r from "./Drawer/BridgeDrawerHost.js";
+import { BridgeDrawerHostMissingError as i, useDrawerAction as a } from "./Drawer/useDrawerAction.js";
+import o from "./Modal/BridgeModalHost.js";
+import { BridgeModalHostMissingError as s, useModalAction as c } from "./Modal/useModalAction.js";
+import l from "./Snackbar/BridgeSnackbarHost.js";
+import { BridgeSnackbarHostMissingError as u, useSnackbarAction as d } from "./Snackbar/useSnackbarAction.js";
+import f from "./BridgeUIHosts.js";
+export { e as BridgeDialogHost, t as BridgeDialogHostMissingError, r as BridgeDrawerHost, i as BridgeDrawerHostMissingError, o as BridgeModalHost, s as BridgeModalHostMissingError, l as BridgeSnackbarHost, u as BridgeSnackbarHostMissingError, f as BridgeUIHosts, n as useDialogAction, a as useDrawerAction, c as useModalAction, d as useSnackbarAction };

package/dist/Components/Badge/badge.types.d.ts

@@ -59,6 +59,6 @@ export interface BadgeSlots {
     /**
      * The content of the badge.
      */
-    default?: Slot;
+    default?: Slot<undefined>;
 }
 export type BadgeProps = MergeHtmlProps<BadgeOwnProps, HTMLAttributes>;

package/dist/Components/Chip/chip.types.d.ts

@@ -88,6 +88,6 @@ export interface ChipSlots {
     /**
      * Chip content. Falls back to `label` when omitted.
      */
-    default?: Slot;
+    default?: Slot<undefined>;
 }
 export type ChipProps = MergeHtmlProps<ChipOwnProps, HTMLAttributes>;

package/dist/Components/Drawer/Drawer.js

@@ -0,0 +1,5 @@
+import e from "./Drawer.vue_vue_type_script_setup_true_lang.js";
+//#region src/Components/Drawer/Drawer.vue
+var t = e;
+//#endregion
+export { t as default };

package/dist/Components/Drawer/Drawer.vue.d.ts

@@ -0,0 +1,39 @@
+import { DrawerOwnProps, DrawerSlots } from './drawer.types';
+type __VLS_Slots = DrawerSlots;
+type __VLS_Props = DrawerOwnProps;
+type __VLS_ModelProps = {
+    modelValue?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_base: import('vue').DefineComponent<__VLS_PublicProps, {
+    stackId: import('vue').ComputedRef<string>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+    close: () => any;
+    "show-change": (show: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    onClose?: (() => any) | undefined;
+    "onShow-change"?: ((show: boolean) => any) | undefined;
+}>, {
+    placement: import('@bridge-ui/core').MergeProps<import('@bridge-ui/core').DrawerPlacement, import('./drawer.types').DrawerPlacementOverrides>;
+    closeOnEscape: boolean;
+    disableScrollLock: boolean;
+    keepMounted: boolean;
+    persistent: boolean;
+    teleportTo: false | string;
+    scroll: import('@bridge-ui/core').MergeProps<import('@bridge-ui/core').DrawerScroll, import('./drawer.types').DrawerScrollOverrides>;
+    autoFocus: boolean;
+    closeOnOverlay: boolean;
+    disableEnforceFocus: boolean;
+    disableRestoreFocus: boolean;
+    hideBackdrop: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Components/Drawer/Drawer.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,96 @@
+import { resolveNamedSlot as e } from "../../Utils/slotOrProp.js";
+import { useDrawer as t } from "./composables/useDrawer.js";
+import { Teleport as n, computed as r, createBlock as i, createCommentVNode as a, createElementBlock as o, createElementVNode as s, defineComponent as c, guardReactiveProps as l, mergeModels as u, mergeProps as d, normalizeProps as f, openBlock as p, resolveDynamicComponent as m, unref as h, useModel as g, useSlots as _ } from "vue";
+//#region src/Components/Drawer/Drawer.vue?vue&type=script&setup=true&lang.ts
+var v = /* @__PURE__ */ c({
+	inheritAttrs: !1,
+	__name: "Drawer",
+	props: /* @__PURE__ */ u({
+		ariaLabel: {},
+		ariaLabelledBy: {},
+		autoFocus: {
+			type: Boolean,
+			default: !1
+		},
+		blur: {},
+		classes: {},
+		closeOnEscape: {
+			type: Boolean,
+			default: !0
+		},
+		closeOnOverlay: {
+			type: Boolean,
+			default: !0
+		},
+		customProps: {},
+		disableEnforceFocus: {
+			type: Boolean,
+			default: !1
+		},
+		disableRestoreFocus: {
+			type: Boolean,
+			default: !1
+		},
+		disableScrollLock: {
+			type: Boolean,
+			default: !1
+		},
+		hideBackdrop: {
+			type: Boolean,
+			default: !1
+		},
+		keepMounted: {
+			type: Boolean,
+			default: !1
+		},
+		persistent: {
+			type: Boolean,
+			default: !1
+		},
+		placement: { default: "left" },
+		scroll: { default: "paper" },
+		size: {},
+		stackId: {},
+		teleportTo: {
+			type: [Boolean, String],
+			default: "body"
+		},
+		transition: {}
+	}, {
+		modelValue: {
+			type: Boolean,
+			default: !1
+		},
+		modelModifiers: {}
+	}),
+	emits: /* @__PURE__ */ u(["close", "show-change"], ["update:modelValue"]),
+	setup(c, { expose: u, emit: v }) {
+		let y = _(), b = v, x = c, { merged: S, mounted: C, rootBind: w, panelBind: T, overlayBind: E, wrapperBind: D, setPanelRef: O, layerStackId: k } = t(x, {
+			size: "md",
+			blur: "none",
+			scroll: "paper",
+			autoFocus: !1,
+			placement: "left",
+			teleportTo: "body",
+			transition: "slide",
+			closeOnEscape: !0,
+			closeOnOverlay: !0
+		}, {
+			show: g(c, "modelValue"),
+			stackId: x.stackId,
+			onClose: () => b("close"),
+			onShowChange: (e) => b("show-change", e)
+		});
+		u({ stackId: r(() => x.stackId ?? k.value) });
+		let A = r(() => S.value.teleportTo === !1), j = r(() => S.value.teleportTo === !1 ? "body" : S.value.teleportTo), M = r(() => x.hideBackdrop !== !0 && S.value.hideBackdrop !== !0);
+		return (t, r) => (p(), i(n, {
+			to: j.value,
+			disabled: A.value
+		}, [h(C) ? (p(), o("div", f(d({ key: 0 }, h(w))), [M.value ? (p(), o("div", d({
+			key: 0,
+			"aria-hidden": "true"
+		}, h(E)), null, 16)) : a("", !0), s("div", f(l(h(D))), [s("div", d({ ref: h(O) }, h(T)), [(p(), i(m(h(e)(h(y), "default"))))], 16)], 16)], 16)) : a("", !0)], 8, ["to", "disabled"]));
+	}
+});
+//#endregion
+export { v as default };

package/dist/Components/Drawer/composables/useDrawer.d.ts

@@ -0,0 +1,63 @@
+import { ComponentPublicInstance, Ref } from 'vue';
+import { LibDefaultsShape, MergeLibDefaults } from '@bridge-ui/core';
+import { DrawerOwnProps, DrawerProps } from '../drawer.types';
+type DrawerLibDefaults = LibDefaultsShape<DrawerOwnProps, "blur" | "size" | "scroll" | "autoFocus" | "placement" | "teleportTo" | "transition" | "closeOnEscape" | "closeOnOverlay">;
+type DrawerMerged = MergeLibDefaults<DrawerOwnProps, DrawerLibDefaults>;
+export type DrawerOptions = {
+    /**
+     * Called when the drawer requests to close.
+     * Sugar for `onShowChange(false)`.
+     */
+    onClose?: () => void;
+    /**
+     * Called when `show` should change (controlled state).
+     */
+    onShowChange?: (show: boolean) => void;
+    /**
+     * Whether the drawer is visible (`defineModel()` / `v-model`).
+     *
+     * @default false
+     */
+    show?: Ref<boolean>;
+    /**
+     * Pre-assigned stack id (BridgeDrawerHost). When omitted, the stack generates a UUID.
+     */
+    stackId?: string;
+};
+export declare function useDrawer(props: DrawerOwnProps, libDefaults: DrawerLibDefaults, options?: DrawerOptions): {
+    merged: import('vue').ComputedRef<DrawerMerged>;
+    mounted: Ref<boolean, boolean>;
+    rootBind: import('vue').ComputedRef<import('@bridge-ui/core').MergePartBind<{
+        onTransitionend: (event: TransitionEvent) => void;
+        style: {
+            zIndex: number;
+        };
+        "aria-hidden": boolean | undefined;
+        class: string;
+    }, "class", import('vue').HTMLAttributes | undefined, Omit<DrawerProps, "size" | "classes" | "customProps" | "placement" | "closeOnEscape" | "disableScrollLock" | "keepMounted" | "persistent" | "teleportTo" | "blur" | "scroll" | "autoFocus" | "closeOnOverlay" | "disableEnforceFocus" | "disableRestoreFocus" | "hideBackdrop" | "stackId" | "transition" | "ariaLabel" | "ariaLabelledBy">>>;
+    panelBind: import('vue').ComputedRef<import('@bridge-ui/core').MergePartBind<{
+        "data-drawer-part": string;
+        "data-state": "open" | "closed";
+        class: string;
+    }, "class", import('vue').HTMLAttributes | undefined, {
+        role: string;
+        "aria-modal": boolean;
+        "aria-label": string | undefined;
+        "aria-labelledby": string | undefined;
+    }>>;
+    overlayBind: import('vue').ComputedRef<import('@bridge-ui/core').MergePartBind<{
+        "data-drawer-part": string;
+        "data-state": "open" | "closed";
+        class: string;
+    }, "class", import('vue').HTMLAttributes | undefined, {
+        onClick: () => void;
+    }>>;
+    wrapperBind: import('vue').ComputedRef<import('@bridge-ui/core').MergePartBind<object, "class", import('vue').HTMLAttributes | undefined, {
+        onClick: (event: MouseEvent) => void;
+    }>>;
+    setPanelRef: (element: null | Element | ComponentPublicInstance) => void;
+    layerStackId: Ref<string, string>;
+    handleOverlayClick: () => void;
+    handleWrapperClick: (event: MouseEvent) => void;
+};
+export {};