@sprawlify/vue 0.0.63 → 0.0.65

package/dist/chunk-BN_g-Awi.js

@@ -0,0 +1,18 @@
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __exportAll = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+export { __exportAll as t };

package/dist/components/collapsible/index.d.ts

@@ -0,0 +1,171 @@
+import { a as Optional, c as PropTypes, r as EmitFn } from "../../types-BQfkZGpL.js";
+import * as vue18 from "vue";
+import { ButtonHTMLAttributes, ComputedRef, HTMLAttributes, MaybeRef, SlotsType, UnwrapRef, h } from "vue";
+import * as collapsible from "@sprawlify/primitives/machines/collapsible";
+import { OpenChangeDetails, OpenChangeDetails as CollapsibleOpenChangeDetails, anatomy as collapsibleAnatomy } from "@sprawlify/primitives/machines/collapsible";
+
+//#region src/components/factory.d.ts
+interface PolymorphicProps {
+  asChild?: boolean;
+}
+//#endregion
+//#region src/components/collapsible/collapsible-content.vue.d.ts
+interface CollapsibleContentBaseProps extends PolymorphicProps {}
+interface CollapsibleContentProps extends CollapsibleContentBaseProps,
+/**
+ * @vue-ignore
+ */
+HTMLAttributes {}
+declare const _default: typeof __VLS_export$5;
+declare const __VLS_export$5: __VLS_WithSlots$5<vue18.DefineComponent<CollapsibleContentProps, {}, {}, {}, {}, vue18.ComponentOptionsMixin, vue18.ComponentOptionsMixin, {}, string, vue18.PublicProps, Readonly<CollapsibleContentProps> & Readonly<{}>, {}, {}, {}, {}, string, vue18.ComponentProvideOptions, false, {}, any>, {
+  default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots$5<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/utils/use-render-strategy.d.ts
+interface RenderStrategyProps {
+  lazyMount?: boolean;
+  unmountOnExit?: boolean;
+}
+//#endregion
+//#region src/components/collapsible/collapsible-types.d.ts
+interface RootProps {
+  collapsedHeight?: number | string;
+  collapsedWidth?: number | string;
+  defaultOpen?: boolean;
+  disabled?: boolean;
+  id?: string;
+  ids?: Partial<{
+    root: string;
+    content: string;
+    trigger: string;
+  }>;
+  lazyMount?: boolean;
+  open?: boolean;
+  unmountOnExit?: boolean;
+}
+type RootEmits = {
+  exitComplete: [];
+  openChange: [details: collapsible.OpenChangeDetails];
+  'update:open': [open: boolean];
+};
+//#endregion
+//#region src/components/collapsible/use-collapsible.d.ts
+interface UseCollapsibleProps extends RenderStrategyProps, Optional<Omit<collapsible.Props, 'dir' | 'getRootNode'>, 'id'> {}
+interface Collapsible extends collapsible.Api<PropTypes> {
+  unmounted?: boolean;
+}
+interface UseCollapsibleReturn extends ComputedRef<Collapsible> {}
+declare const useCollapsible: (props?: MaybeRef<UseCollapsibleProps>, emits?: EmitFn<RootEmits>) => UseCollapsibleReturn;
+//#endregion
+//#region src/components/collapsible/use-collapsible-context.d.ts
+interface UseCollapsibleContext extends UseCollapsibleReturn {}
+//#endregion
+//#region src/components/collapsible/collapsible-context.vue.d.ts
+interface CollapsibleContextProps extends SlotsType<{
+  default: UnwrapRef<UseCollapsibleContext>;
+}> {}
+declare const _default$1: typeof __VLS_export$4;
+declare const __VLS_export$4: __VLS_WithSlots$4<vue18.DefineComponent<{}, {}, {}, {}, {}, vue18.ComponentOptionsMixin, vue18.ComponentOptionsMixin, {}, string, vue18.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue18.ComponentProvideOptions, true, {}, any>, {
+  default(collapsible: UnwrapRef<UseCollapsibleContext>): unknown;
+}>;
+type __VLS_WithSlots$4<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/collapsible/collapsible-root-provider.vue.d.ts
+interface RootProviderProps {
+  value: UnwrapRef<UseCollapsibleReturn>;
+}
+interface CollapsibleRootProviderBaseProps extends RootProviderProps, PolymorphicProps {}
+interface CollapsibleRootProviderProps extends CollapsibleRootProviderBaseProps,
+/**
+ * @vue-ignore
+ */
+HTMLAttributes {}
+declare const _default$4: typeof __VLS_export$3;
+declare const __VLS_export$3: __VLS_WithSlots$3<vue18.DefineComponent<CollapsibleRootProviderProps, {}, {}, {}, {}, vue18.ComponentOptionsMixin, vue18.ComponentOptionsMixin, {}, string, vue18.PublicProps, Readonly<CollapsibleRootProviderProps> & Readonly<{}>, {}, {}, {}, {}, string, vue18.ComponentProvideOptions, false, {}, any>, {
+  default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots$3<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/collapsible/collapsible-root.vue.d.ts
+interface CollapsibleRootBaseProps extends RootProps, PolymorphicProps {}
+interface CollapsibleRootProps extends CollapsibleRootBaseProps,
+/**
+ * @vue-ignore
+ */
+HTMLAttributes {}
+interface CollapsibleRootEmits extends RootEmits {}
+declare const _default$3: typeof __VLS_export$2;
+declare const __VLS_export$2: __VLS_WithSlots$2<vue18.DefineComponent<CollapsibleRootProps, {}, {}, {}, {}, vue18.ComponentOptionsMixin, vue18.ComponentOptionsMixin, {
+  exitComplete: () => any;
+  openChange: (details: collapsible.OpenChangeDetails) => any;
+  "update:open": (open: boolean) => any;
+}, string, vue18.PublicProps, Readonly<CollapsibleRootProps> & Readonly<{
+  onExitComplete?: (() => any) | undefined;
+  onOpenChange?: ((details: collapsible.OpenChangeDetails) => any) | undefined;
+  "onUpdate:open"?: ((open: boolean) => any) | undefined;
+}>, {
+  defaultOpen: boolean;
+  disabled: boolean;
+  lazyMount: boolean;
+  open: boolean;
+  unmountOnExit: boolean;
+}, {}, {}, {}, string, vue18.ComponentProvideOptions, false, {}, any>, {
+  default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots$2<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/collapsible/collapsible-trigger.vue.d.ts
+interface CollapsibleTriggerBaseProps extends PolymorphicProps {}
+interface CollapsibleTriggerProps extends CollapsibleTriggerBaseProps,
+/**
+ * @vue-ignore
+ */
+ButtonHTMLAttributes {}
+declare const _default$5: typeof __VLS_export$1;
+declare const __VLS_export$1: __VLS_WithSlots$1<vue18.DefineComponent<CollapsibleTriggerProps, {}, {}, {}, {}, vue18.ComponentOptionsMixin, vue18.ComponentOptionsMixin, {}, string, vue18.PublicProps, Readonly<CollapsibleTriggerProps> & Readonly<{}>, {}, {}, {}, {}, string, vue18.ComponentProvideOptions, false, {}, any>, {
+  default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots$1<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/collapsible/collapsible-indicator.vue.d.ts
+interface CollapsibleIndicatorBaseProps extends PolymorphicProps {}
+interface CollapsibleIndicatorProps extends CollapsibleIndicatorBaseProps,
+/**
+ * @vue-ignore
+ */
+HTMLAttributes {}
+declare const _default$2: typeof __VLS_export;
+declare const __VLS_export: __VLS_WithSlots<vue18.DefineComponent<CollapsibleIndicatorProps, {}, {}, {}, {}, vue18.ComponentOptionsMixin, vue18.ComponentOptionsMixin, {}, string, vue18.PublicProps, Readonly<CollapsibleIndicatorProps> & Readonly<{}>, {}, {}, {}, {}, string, vue18.ComponentProvideOptions, false, {}, any>, {
+  default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+declare namespace collapsible_d_exports {
+  export { _default as Content, CollapsibleContentBaseProps as ContentBaseProps, CollapsibleContentProps as ContentProps, _default$1 as Context, CollapsibleContextProps as ContextProps, _default$2 as Indicator, CollapsibleIndicatorBaseProps as IndicatorBaseProps, CollapsibleIndicatorProps as IndicatorProps, OpenChangeDetails, _default$3 as Root, CollapsibleRootBaseProps as RootBaseProps, CollapsibleRootEmits as RootEmits, CollapsibleRootProps as RootProps, _default$4 as RootProvider, CollapsibleRootProviderBaseProps as RootProviderBaseProps, CollapsibleRootProviderProps as RootProviderProps, _default$5 as Trigger, CollapsibleTriggerBaseProps as TriggerBaseProps, CollapsibleTriggerProps as TriggerProps };
+}
+//#endregion
+export { collapsible_d_exports as Collapsible, _default as CollapsibleContent, type CollapsibleContentBaseProps, type CollapsibleContentProps, _default$1 as CollapsibleContext, type CollapsibleContextProps, _default$2 as CollapsibleIndicator, type CollapsibleIndicatorBaseProps, type CollapsibleIndicatorProps, type CollapsibleOpenChangeDetails, _default$3 as CollapsibleRoot, type CollapsibleRootBaseProps, type CollapsibleRootEmits, type CollapsibleRootProps, _default$4 as CollapsibleRootProvider, type CollapsibleRootProviderBaseProps, type CollapsibleRootProviderProps, _default$5 as CollapsibleTrigger, type CollapsibleTriggerBaseProps, type CollapsibleTriggerProps, type UseCollapsibleContext, type UseCollapsibleProps, type UseCollapsibleReturn, collapsibleAnatomy, useCollapsible, useCollapsibleContext };

package/dist/components/collapsible/index.js

@@ -0,0 +1,327 @@
+import { t as __exportAll } from "../../chunk-BN_g-Awi.js";
+import { a as DEFAULT_LOCALE, c as DEFAULT_ENVIRONMENT, d as mergeProps$1, f as useMachine, l as useEnvironmentContext, o as useLocaleContext, p as normalizeProps$1, t as useForwardExpose, u as createContext } from "../../use-forward-expose-BIk4OI3R.js";
+import { Fragment, cloneVNode, computed, createBlock, createCommentVNode, defineComponent, guardReactiveProps, h, mergeDefaults, mergeProps, normalizeProps, openBlock, ref, renderSlot, toValue, unref, useId, watch, withCtx } from "vue";
+import * as collapsible from "@sprawlify/primitives/machines/collapsible";
+import { anatomy as collapsibleAnatomy } from "@sprawlify/primitives/machines/collapsible";
+
+//#region src/utils/dynamic.ts
+const Dynamic = defineComponent({
+	name: "Dynamic",
+	inheritAttrs: false,
+	setup(_, { attrs, slots }) {
+		return () => {
+			if (!slots.default) return null;
+			const children = renderSlotFragments(slots.default());
+			const [firstChildren, ...otherChildren] = children;
+			if (Object.keys(attrs).length > 0) {
+				delete firstChildren.props?.ref;
+				const mergedProps = mergeProps$1(attrs, firstChildren.props ?? {});
+				const cloned = cloneVNode(firstChildren, mergedProps);
+				for (const prop in mergedProps) if (prop.startsWith("on")) {
+					cloned.props ||= {};
+					cloned.props[prop] = mergedProps[prop];
+				}
+				return children.length === 1 ? cloned : [cloned, ...otherChildren];
+			}
+			return children;
+		};
+	}
+});
+function renderSlotFragments(children) {
+	if (!children) return [];
+	return children.flatMap((child) => {
+		if (child.type === Fragment) return renderSlotFragments(child.children);
+		return [child];
+	});
+}
+
+//#endregion
+//#region src/components/factory.ts
+const SELF_CLOSING_TAGS = "br, hr, img, input, area, textarea".split(", ");
+const isSelfClosingTag = (tag) => typeof tag === "string" && SELF_CLOSING_TAGS.includes(tag);
+const withAsChild = (component) => {
+	return defineComponent({
+		name: "Polymorphic",
+		inheritAttrs: false,
+		props: { asChild: {
+			type: Boolean,
+			default: false
+		} },
+		setup(props, { attrs, slots }) {
+			if (!props.asChild) return () => h(component, attrs, isSelfClosingTag(component) ? void 0 : slots.default?.());
+			return () => h(Dynamic, attrs, slots);
+		}
+	});
+};
+function jsxFactory() {
+	const cache = /* @__PURE__ */ new Map();
+	return new Proxy(withAsChild, {
+		apply(_target, _thisArg, argArray) {
+			return withAsChild(argArray[0]);
+		},
+		get(_, element) {
+			if (!cache.has(element)) cache.set(element, withAsChild(element));
+			return cache.get(element);
+		}
+	});
+}
+const sprawlify = jsxFactory();
+
+//#endregion
+//#region src/components/collapsible/use-collapsible-context.ts
+const [CollapsibleProvider, useCollapsibleContext] = createContext("CollapsibleContext");
+
+//#endregion
+//#region src/components/collapsible/collapsible-content.vue?vue&type=script&setup=true&lang.ts
+var collapsible_content_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "collapsible-content",
+	props: { asChild: {
+		type: Boolean,
+		required: false
+	} },
+	setup(__props) {
+		const collapsible = useCollapsibleContext();
+		useForwardExpose();
+		return (_ctx, _cache) => {
+			return !unref(collapsible).unmounted ? (openBlock(), createBlock(unref(sprawlify).div, mergeProps({ key: 0 }, unref(collapsible).getContentProps(), { "as-child": __props.asChild }), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 16, ["as-child"])) : createCommentVNode("v-if", true);
+		};
+	}
+});
+
+//#endregion
+//#region src/components/collapsible/collapsible-content.vue
+var collapsible_content_default = collapsible_content_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+//#region src/components/collapsible/collapsible-context.vue?vue&type=script&setup=true&lang.ts
+var collapsible_context_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "collapsible-context",
+	setup(__props) {
+		const collapsible = useCollapsibleContext();
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(unref(collapsible))));
+		};
+	}
+});
+
+//#endregion
+//#region src/components/collapsible/collapsible-context.vue
+var collapsible_context_default = collapsible_context_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+//#region src/components/collapsible/collapsible-root-provider.vue?vue&type=script&setup=true&lang.ts
+var collapsible_root_provider_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "collapsible-root-provider",
+	props: {
+		value: {
+			type: null,
+			required: true
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		const collapsible = computed(() => props.value);
+		CollapsibleProvider(collapsible);
+		useForwardExpose();
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(sprawlify).div, mergeProps(collapsible.value.getRootProps(), { "as-child": __props.asChild }), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 16, ["as-child"]);
+		};
+	}
+});
+
+//#endregion
+//#region src/components/collapsible/collapsible-root-provider.vue
+var collapsible_root_provider_default = collapsible_root_provider_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+//#region src/utils/clean-props.ts
+const cleanProps = (obj) => {
+	const result = {};
+	for (const [key, value] of Object.entries(obj)) if (value !== void 0) result[key] = value;
+	return result;
+};
+
+//#endregion
+//#region src/components/collapsible/use-collapsible.ts
+const useCollapsible = (props = {}, emits) => {
+	const id = useId();
+	const env = useEnvironmentContext(DEFAULT_ENVIRONMENT);
+	const locale = useLocaleContext(DEFAULT_LOCALE);
+	const context = computed(() => {
+		const localeProps = toValue(props);
+		return {
+			id,
+			dir: locale.value.dir,
+			getRootNode: env?.value.getRootNode,
+			...cleanProps(localeProps),
+			onExitComplete: () => {
+				emits?.("exitComplete");
+				localeProps.onExitComplete?.();
+			},
+			onOpenChange: (details) => {
+				emits?.("openChange", details);
+				emits?.("update:open", details.open);
+				localeProps.onOpenChange?.(details);
+			}
+		};
+	});
+	const service = useMachine(collapsible.machine, context);
+	const api = computed(() => collapsible.connect(service, normalizeProps$1));
+	const wasVisible = ref(false);
+	watch(() => api.value.visible, () => {
+		if (api.value.visible) wasVisible.value = true;
+	});
+	return computed(() => {
+		const localeProps = toValue(props);
+		return {
+			...api.value,
+			unmounted: !api.value.visible && !wasVisible.value && localeProps.lazyMount || localeProps.unmountOnExit && !api.value.visible && wasVisible.value
+		};
+	});
+};
+
+//#endregion
+//#region src/components/collapsible/collapsible-root.vue?vue&type=script&setup=true&lang.ts
+var collapsible_root_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "collapsible-root",
+	props: /* @__PURE__ */ mergeDefaults({
+		collapsedHeight: {
+			type: [Number, String],
+			required: false
+		},
+		collapsedWidth: {
+			type: [Number, String],
+			required: false
+		},
+		defaultOpen: {
+			type: Boolean,
+			required: false
+		},
+		disabled: {
+			type: Boolean,
+			required: false
+		},
+		id: {
+			type: String,
+			required: false
+		},
+		ids: {
+			type: Object,
+			required: false
+		},
+		lazyMount: {
+			type: Boolean,
+			required: false
+		},
+		open: {
+			type: Boolean,
+			required: false
+		},
+		unmountOnExit: {
+			type: Boolean,
+			required: false
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		}
+	}, {
+		defaultOpen: void 0,
+		disabled: void 0,
+		lazyMount: void 0,
+		open: void 0,
+		unmountOnExit: void 0
+	}),
+	emits: [
+		"exitComplete",
+		"openChange",
+		"update:open"
+	],
+	setup(__props, { emit: __emit }) {
+		const collapsible = useCollapsible(__props, __emit);
+		CollapsibleProvider(collapsible);
+		useForwardExpose();
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(sprawlify).div, mergeProps(unref(collapsible).getRootProps(), { "as-child": __props.asChild }), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 16, ["as-child"]);
+		};
+	}
+});
+
+//#endregion
+//#region src/components/collapsible/collapsible-root.vue
+var collapsible_root_default = collapsible_root_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+//#region src/components/collapsible/collapsible-trigger.vue?vue&type=script&setup=true&lang.ts
+var collapsible_trigger_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "collapsible-trigger",
+	props: { asChild: {
+		type: Boolean,
+		required: false
+	} },
+	setup(__props) {
+		const collapsible = useCollapsibleContext();
+		useForwardExpose();
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(sprawlify).button, mergeProps(unref(collapsible).getTriggerProps(), { "as-child": __props.asChild }), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 16, ["as-child"]);
+		};
+	}
+});
+
+//#endregion
+//#region src/components/collapsible/collapsible-trigger.vue
+var collapsible_trigger_default = collapsible_trigger_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+//#region src/components/collapsible/collapsible-indicator.vue?vue&type=script&setup=true&lang.ts
+var collapsible_indicator_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "collapsible-indicator",
+	props: { asChild: {
+		type: Boolean,
+		required: false
+	} },
+	setup(__props) {
+		const collapsible = useCollapsibleContext();
+		useForwardExpose();
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(sprawlify).div, mergeProps(unref(collapsible).getIndicatorProps(), { "as-child": __props.asChild }), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 16, ["as-child"]);
+		};
+	}
+});
+
+//#endregion
+//#region src/components/collapsible/collapsible-indicator.vue
+var collapsible_indicator_default = collapsible_indicator_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+//#region src/components/collapsible/collapsible.ts
+var collapsible_exports = /* @__PURE__ */ __exportAll({
+	Content: () => collapsible_content_default,
+	Context: () => collapsible_context_default,
+	Indicator: () => collapsible_indicator_default,
+	Root: () => collapsible_root_default,
+	RootProvider: () => collapsible_root_provider_default,
+	Trigger: () => collapsible_trigger_default
+});
+
+//#endregion
+export { collapsible_exports as Collapsible, collapsible_content_default as CollapsibleContent, collapsible_context_default as CollapsibleContext, collapsible_indicator_default as CollapsibleIndicator, collapsible_root_default as CollapsibleRoot, collapsible_root_provider_default as CollapsibleRootProvider, collapsible_trigger_default as CollapsibleTrigger, collapsibleAnatomy, useCollapsible, useCollapsibleContext };

package/dist/index.d.ts

@@ -1,22 +1,92 @@
-import { Machine, MachineSchema, Service, mergeProps } from "@sprawlify/primitives/core";
-import * as _sprawlify_primitives_types0 from "@sprawlify/primitives/types";
-import * as Vue from "vue";
-import { ComputedRef, Ref } from "vue";
+import { a as Optional, c as PropTypes, i as MaybePromise, l as normalizeProps, n as BooleanDefaults, o as mergeProps, r as EmitFn, s as useMachine, t as Assign } from "./types-BQfkZGpL.js";
+import * as vue8 from "vue";
+import { ComponentPublicInstance, ComputedRef, MaybeRef, MaybeRefOrGetter, UnwrapRef } from "vue";
+import { FilterOptions, FilterReturn, Locale } from "@sprawlify/primitives/i18n-utils";
 
-//#region src/core/normalize-props.d.ts
-type ReservedProps = {
-  key?: string | number | symbol | undefined;
-  ref?: Vue.VNodeRef | undefined;
+//#region src/providers/environment/use-environment-context.d.ts
+type RootNode = ShadowRoot | Document | Node;
+interface UseEnvironmentContext {
+  /**
+   * The root node of the application.
+   * This is used to determine the window and document objects.
+   */
+  getRootNode(): RootNode;
+  /**
+   * The document context for the root node.
+   */
+  getDocument(): Document;
+  /**
+   * The window context for the root node.
+   */
+  getWindow(): Window & typeof globalThis;
+}
+declare const DEFAULT_ENVIRONMENT: ComputedRef<UseEnvironmentContext>;
+//#endregion
+//#region src/providers/environment/environment-provider.vue.d.ts
+interface EnvironmentProviderProps {
+  value?: RootNode | (() => RootNode);
+}
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+  default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: vue8.DefineComponent<EnvironmentProviderProps, {}, {}, {}, {}, vue8.ComponentOptionsMixin, vue8.ComponentOptionsMixin, {}, string, vue8.PublicProps, Readonly<EnvironmentProviderProps> & Readonly<{}>, {}, {}, {}, {}, string, vue8.ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export$1: __VLS_WithSlots$1<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export$1;
+type __VLS_WithSlots$1<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
 };
-type Attrs<T> = T & ReservedProps;
-type PropTypes = Vue.NativeElements & {
-  element: Attrs<Vue.HTMLAttributes>;
-  style: Vue.CSSProperties;
+//#endregion
+//#region src/providers/locale/locale-provider.vue.d.ts
+interface LocaleProviderProps {
+  locale: string;
+}
+declare const _default$1: typeof __VLS_export;
+declare const __VLS_export: __VLS_WithSlots<vue8.DefineComponent<LocaleProviderProps, {}, {}, {}, {}, vue8.ComponentOptionsMixin, vue8.ComponentOptionsMixin, {}, string, vue8.PublicProps, Readonly<LocaleProviderProps> & Readonly<{}>, {}, {}, {}, {}, string, vue8.ComponentProvideOptions, false, {}, any>, {
+  default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
 };
-declare const normalizeProps: _sprawlify_primitives_types0.NormalizeProps<PropTypes>;
 //#endregion
-//#region src/core/machine.d.ts
-type MaybeRef<T> = T | Ref<T> | ComputedRef<T>;
-declare function useMachine<T extends MachineSchema>(machine: Machine<T>, userProps?: MaybeRef<Partial<T["props"]>>): Service<T>;
+//#region src/providers/locale/use-collator.d.ts
+interface UseCollatorProps extends Intl.CollatorOptions {
+  locale?: string;
+}
+interface UseCollatorReturn extends ComputedRef<Intl.Collator> {}
+declare function useCollator(propsOrFn?: MaybeRef<UseCollatorProps>): UseCollatorReturn;
+//#endregion
+//#region src/providers/locale/use-filter.d.ts
+interface UseFilterProps extends FilterOptions {}
+declare function useFilter(props: UseFilterProps): UseFilterReturn;
+interface UseFilterReturn extends ComputedRef<FilterReturn> {}
+//#endregion
+//#region src/providers/locale/use-locale-context.d.ts
+interface LocaleContext extends Locale {}
+declare const DEFAULT_LOCALE: ComputedRef<LocaleContext>;
+//#endregion
+//#region src/utils/create-context.d.ts
+type CreateContextReturn<T> = [(opts: T) => void, (fallback?: T) => T, symbol];
+declare const createContext: <T>(id: string) => CreateContextReturn<T>;
+//#endregion
+//#region src/utils/use-emits-as-props.d.ts
+declare function useEmitAsProps<Name extends string>(emit: (name: Name, ...args: any[]) => void): Record<string, any>;
+//#endregion
+//#region src/utils/use-forward-expose.d.ts
+declare function useForwardExpose(): {
+  forwardRef: (ref: Element | ComponentPublicInstance | null) => void;
+  currentRef: vue8.Ref<Element | ComponentPublicInstance | null | undefined, Element | ComponentPublicInstance | null | undefined>;
+  currentElement: vue8.ComputedRef<HTMLElement>;
+};
+//#endregion
+//#region src/utils/use-forward-props.d.ts
+declare function useForwardProps<T extends MaybeRefOrGetter<Record<string, any>>, U extends UnwrapRef<T>>(props: T): vue8.ComputedRef<U>;
+//#endregion
+//#region src/utils/use-forward-props-emits.d.ts
+declare function useForwardPropsEmits<T extends Parameters<typeof useForwardProps>[0], Name extends string>(props: T, emit?: (name: Name, ...args: any[]) => void): vue8.ComputedRef<any>;
 //#endregion
-export { PropTypes, mergeProps, normalizeProps, useMachine };
+export { Assign, BooleanDefaults, DEFAULT_ENVIRONMENT, DEFAULT_LOCALE, EmitFn, _default as EnvironmentProvider, type EnvironmentProviderProps, type LocaleContext, _default$1 as LocaleProvider, type LocaleProviderProps, MaybePromise, Optional, PropTypes, type RootNode, type UseCollatorProps, type UseCollatorReturn, type UseEnvironmentContext, type UseFilterProps, type UseFilterReturn, createContext, mergeProps, normalizeProps, useCollator, useEmitAsProps, useEnvironmentContext, useFilter, useForwardExpose, useForwardProps, useForwardPropsEmits, useLocaleContext, useMachine };