@youcan/celeste 0.6.3

package/dist/cjs/tab-menu-content.js

@@ -0,0 +1,32 @@
+"use strict";
+const Mo = require("vue");
+const useDelegatedProps = require("./use-delegated-props.js");
+const clsx = require("./chunks/clsx.js");
+const index = require("./chunks/index.js");
+const _pluginVue_exportHelper = require("./chunks/_plugin-vue_export-helper.js");
+const _sfc_main = /* @__PURE__ */ Mo.defineComponent({
+  __name: "tab-menu-content",
+  props: {
+    value: {},
+    forceMount: { type: Boolean },
+    asChild: { type: Boolean },
+    as: {},
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const delegatedProps = useDelegatedProps.useDelegatedProps(props, "class");
+    return (_ctx, _cache) => {
+      return Mo.openBlock(), Mo.createBlock(Mo.unref(index.bg), Mo.mergeProps({
+        class: Mo.unref(clsx.clsx)("celeste-tab-menu-content", props.class)
+      }, Mo.unref(delegatedProps)), {
+        default: Mo.withCtx(() => [
+          Mo.renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ]),
+        _: 3
+      }, 16, ["class"]);
+    };
+  }
+});
+const tabMenuContent = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["__scopeId", "data-v-85c57bdc"]]);
+module.exports = tabMenuContent;

package/dist/cjs/tab-menu-item.js

@@ -0,0 +1,44 @@
+"use strict";
+const Mo = require("vue");
+const useDelegatedProps = require("./use-delegated-props.js");
+const clsx = require("./chunks/clsx.js");
+const index = require("./chunks/index.js");
+const _pluginVue_exportHelper = require("./chunks/_plugin-vue_export-helper.js");
+const _hoisted_1 = {
+  key: 0,
+  class: "celeste-tab-menu-item-label"
+};
+const _sfc_main = /* @__PURE__ */ Mo.defineComponent({
+  __name: "tab-menu-item",
+  props: {
+    value: {},
+    disabled: { type: Boolean },
+    asChild: { type: Boolean },
+    as: {},
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const delegatedProps = useDelegatedProps.useDelegatedProps(props, "class");
+    const forwardedProps = index.At(delegatedProps);
+    return (_ctx, _cache) => {
+      return Mo.openBlock(), Mo.createBlock(Mo.unref(index.Cg), Mo.mergeProps(Mo.unref(forwardedProps), {
+        class: Mo.unref(clsx.clsx)(
+          "celeste-tab-menu-item",
+          props.class
+        )
+      }), {
+        default: Mo.withCtx(() => [
+          Mo.renderSlot(_ctx.$slots, "prefix", {}, void 0, true),
+          _ctx.$slots.default ? (Mo.openBlock(), Mo.createElementBlock("span", _hoisted_1, [
+            Mo.renderSlot(_ctx.$slots, "default", {}, void 0, true)
+          ])) : Mo.createCommentVNode("", true),
+          Mo.renderSlot(_ctx.$slots, "postfix", {}, void 0, true)
+        ]),
+        _: 3
+      }, 16, ["class"]);
+    };
+  }
+});
+const tabMenuItem = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["__scopeId", "data-v-ca8f5a83"]]);
+module.exports = tabMenuItem;

package/dist/cjs/tab-menu-list.js

@@ -0,0 +1,34 @@
+"use strict";
+const Mo = require("vue");
+const useDelegatedProps = require("./use-delegated-props.js");
+const clsx = require("./chunks/clsx.js");
+const index = require("./chunks/index.js");
+const _pluginVue_exportHelper = require("./chunks/_plugin-vue_export-helper.js");
+const _sfc_main = /* @__PURE__ */ Mo.defineComponent({
+  __name: "tab-menu-list",
+  props: {
+    loop: { type: Boolean },
+    asChild: { type: Boolean },
+    as: {},
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const delegatedProps = useDelegatedProps.useDelegatedProps(props, "class");
+    return (_ctx, _cache) => {
+      return Mo.openBlock(), Mo.createBlock(Mo.unref(index.gg), Mo.mergeProps(Mo.unref(delegatedProps), {
+        class: Mo.unref(clsx.clsx)(
+          "celeste-tab-menu-list",
+          props.class
+        )
+      }), {
+        default: Mo.withCtx(() => [
+          Mo.renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ]),
+        _: 3
+      }, 16, ["class"]);
+    };
+  }
+});
+const tabMenuList = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["__scopeId", "data-v-9877f1df"]]);
+module.exports = tabMenuList;

package/dist/cjs/tab-menu.js

@@ -0,0 +1,32 @@
+"use strict";
+const Mo = require("vue");
+const index = require("./chunks/index.js");
+const _pluginVue_exportHelper = require("./chunks/_plugin-vue_export-helper.js");
+const _sfc_main = /* @__PURE__ */ Mo.defineComponent({
+  __name: "tab-menu",
+  props: {
+    defaultValue: {},
+    orientation: {},
+    dir: {},
+    activationMode: {},
+    modelValue: {},
+    asChild: { type: Boolean },
+    as: {}
+  },
+  emits: ["update:modelValue"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const forwarded = index.xe(props, emits);
+    return (_ctx, _cache) => {
+      return Mo.openBlock(), Mo.createBlock(Mo.unref(index.yg), Mo.mergeProps(Mo.unref(forwarded), { class: "celeste-tab-menu-root" }), {
+        default: Mo.withCtx(() => [
+          Mo.renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ]),
+        _: 3
+      }, 16);
+    };
+  }
+});
+const tabMenu = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["__scopeId", "data-v-b5afb6cc"]]);
+module.exports = tabMenu;

package/dist/cjs/text-input-affix.js

@@ -0,0 +1,28 @@
+"use strict";
+const Mo = require("vue");
+const useDelegatedProps = require("./use-delegated-props.js");
+const clsx = require("./chunks/clsx.js");
+;/* empty css                                                                         */
+const _pluginVue_exportHelper = require("./chunks/_plugin-vue_export-helper.js");
+const _sfc_main = /* @__PURE__ */ Mo.defineComponent({
+  __name: "text-input-affix",
+  props: {
+    class: {},
+    variant: { default: "prefix" },
+    inline: { type: Boolean },
+    asKbd: { type: Boolean }
+  },
+  setup(__props) {
+    const props = __props;
+    const delegatedProps = useDelegatedProps.useDelegatedProps(props, "class");
+    return (_ctx, _cache) => {
+      return Mo.openBlock(), Mo.createElementBlock("span", Mo.mergeProps(Mo.unref(delegatedProps), {
+        class: Mo.unref(clsx.clsx)("celeste-text-input-affix", props.class)
+      }), [
+        Mo.renderSlot(_ctx.$slots, "default", {}, void 0, true)
+      ], 16);
+    };
+  }
+});
+const textInputAffix = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["__scopeId", "data-v-a78ff6e3"]]);
+module.exports = textInputAffix;

package/dist/cjs/text-input-button.js

@@ -0,0 +1,32 @@
+"use strict";
+const Mo = require("vue");
+const button = require("./button.js");
+const useDelegatedProps = require("./use-delegated-props.js");
+const clsx = require("./chunks/clsx.js");
+;/* empty css                                                                          */
+const _pluginVue_exportHelper = require("./chunks/_plugin-vue_export-helper.js");
+const _sfc_main = /* @__PURE__ */ Mo.defineComponent({
+  __name: "text-input-button",
+  props: {
+    inline: { type: Boolean, default: false }
+  },
+  setup(__props) {
+    const props = __props;
+    const delegatedProps = useDelegatedProps.useDelegatedProps(props, "class");
+    return (_ctx, _cache) => {
+      return Mo.openBlock(), Mo.createBlock(button, Mo.mergeProps(Mo.unref(delegatedProps), {
+        size: "sm",
+        intent: "neutral",
+        variant: "stroke",
+        class: Mo.unref(clsx.clsx)("celeste-text-input-button", props.class)
+      }), {
+        default: Mo.withCtx(() => [
+          Mo.renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ]),
+        _: 3
+      }, 16, ["class"]);
+    };
+  }
+});
+const textInputButton = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["__scopeId", "data-v-82489224"]]);
+module.exports = textInputButton;

package/dist/cjs/text-input-icon.js

@@ -0,0 +1,29 @@
+"use strict";
+const Mo = require("vue");
+const useDelegatedProps = require("./use-delegated-props.js");
+const clsx = require("./chunks/clsx.js");
+;/* empty css                                                                        */
+const _pluginVue_exportHelper = require("./chunks/_plugin-vue_export-helper.js");
+const _sfc_main = /* @__PURE__ */ Mo.defineComponent({
+  __name: "text-input-icon",
+  props: {
+    icon: {},
+    position: { default: "start" },
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const delegatedProps = useDelegatedProps.useDelegatedProps(props, "class");
+    return (_ctx, _cache) => {
+      return Mo.openBlock(), Mo.createElementBlock("div", Mo.mergeProps(Mo.unref(delegatedProps), {
+        class: Mo.unref(clsx.clsx)("celeste-text-input-icon", props.class)
+      }), [
+        Mo.createElementVNode("i", {
+          class: Mo.normalizeClass(_ctx.icon)
+        }, null, 2)
+      ], 16);
+    };
+  }
+});
+const textInputIcon = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["__scopeId", "data-v-3b859b72"]]);
+module.exports = textInputIcon;

package/dist/cjs/text-input.js

@@ -0,0 +1,41 @@
+"use strict";
+const Mo = require("vue");
+const clsx = require("./chunks/clsx.js");
+const _pluginVue_exportHelper = require("./chunks/_plugin-vue_export-helper.js");
+const _hoisted_1 = ["size", "has-error"];
+const _hoisted_2 = ["type"];
+const _sfc_main = /* @__PURE__ */ Mo.defineComponent({
+  __name: "text-input",
+  props: /* @__PURE__ */ Mo.mergeModels({
+    type: { default: "text" },
+    size: { default: "sm" },
+    hasError: { type: Boolean, default: false }
+  }, {
+    "modelValue": {},
+    "modelModifiers": {}
+  }),
+  emits: ["update:modelValue"],
+  setup(__props) {
+    const props = __props;
+    const modelValue = Mo.useModel(__props, "modelValue");
+    return (_ctx, _cache) => {
+      return Mo.openBlock(), Mo.createElementBlock("label", {
+        size: _ctx.size,
+        "has-error": _ctx.hasError,
+        class: "celeste-text-input-wrapper"
+      }, [
+        Mo.withDirectives(Mo.createElementVNode("input", Mo.mergeProps({
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => modelValue.value = $event)
+        }, _ctx.$attrs, {
+          type: _ctx.type,
+          class: Mo.unref(clsx.clsx)("celeste-text-input", props.class)
+        }), null, 16, _hoisted_2), [
+          [Mo.vModelDynamic, modelValue.value]
+        ]),
+        Mo.renderSlot(_ctx.$slots, "default", {}, void 0, true)
+      ], 8, _hoisted_1);
+    };
+  }
+});
+const TextInput = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["__scopeId", "data-v-a28be4ca"]]);
+module.exports = TextInput;

package/dist/cjs/textarea.js

@@ -0,0 +1,56 @@
+"use strict";
+const Mo = require("vue");
+const clsx = require("./chunks/clsx.js");
+const _pluginVue_exportHelper = require("./chunks/_plugin-vue_export-helper.js");
+const _hoisted_1 = ["aria-disabled"];
+const _hoisted_2 = ["placeholder", "maxlength", "disabled"];
+const _hoisted_3 = {
+  key: 0,
+  class: "celeste-textarea-count"
+};
+const _sfc_main = /* @__PURE__ */ Mo.defineComponent({
+  __name: "textarea",
+  props: /* @__PURE__ */ Mo.mergeModels({
+    class: {},
+    placeholder: { default: "Placeholder" },
+    showCount: { type: Boolean, default: true },
+    disabled: { type: Boolean, default: false },
+    maxLength: {}
+  }, {
+    "modelValue": {},
+    "modelModifiers": {}
+  }),
+  emits: ["update:modelValue"],
+  setup(__props) {
+    const props = __props;
+    const modelValue = Mo.useModel(__props, "modelValue");
+    return (_ctx, _cache) => {
+      var _a;
+      return Mo.openBlock(), Mo.createElementBlock("div", {
+        class: Mo.normalizeClass(Mo.unref(clsx.clsx)(
+          "celeste-textarea-wrapper",
+          props.class
+        )),
+        "aria-disabled": _ctx.disabled,
+        onClick: _cache[1] || (_cache[1] = ($event) => {
+          var _a2;
+          return (_a2 = _ctx.$el.querySelector("textarea")) == null ? void 0 : _a2.focus();
+        })
+      }, [
+        Mo.withDirectives(Mo.createElementVNode("textarea", Mo.mergeProps({
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => modelValue.value = $event)
+        }, _ctx.$attrs, {
+          placeholder: _ctx.placeholder,
+          maxlength: _ctx.maxLength,
+          disabled: _ctx.disabled,
+          class: "celeste-textarea"
+        }), null, 16, _hoisted_2), [
+          [Mo.vModelText, modelValue.value]
+        ]),
+        _ctx.showCount && Number(_ctx.maxLength) ? (Mo.openBlock(), Mo.createElementBlock("span", _hoisted_3, Mo.toDisplayString(`${((_a = modelValue.value) == null ? void 0 : _a.length) || 0}/${_ctx.maxLength}`), 1)) : Mo.createCommentVNode("", true)
+      ], 10, _hoisted_1);
+    };
+  }
+});
+const textarea = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["__scopeId", "data-v-76864cee"]]);
+module.exports = textarea;

package/dist/cjs/tooltip.js

@@ -0,0 +1,115 @@
+"use strict";
+const Mo = require("vue");
+const compactButton = require("./compact-button.js");
+const clsx = require("./chunks/clsx.js");
+const index = require("./chunks/index.js");
+const _pluginVue_exportHelper = require("./chunks/_plugin-vue_export-helper.js");
+const _hoisted_1 = { class: "celeste-tooltip-content-box" };
+const _hoisted_2 = {
+  key: 0,
+  class: "celeste-tooltip-content-title"
+};
+const _hoisted_3 = {
+  key: 1,
+  class: "celeste-tooltip-content-description"
+};
+const _sfc_main = /* @__PURE__ */ Mo.defineComponent({
+  __name: "tooltip",
+  props: {
+    class: {},
+    size: { default: "sm" },
+    variant: { default: "light" },
+    icon: {},
+    title: {},
+    description: {},
+    dismissible: { type: Boolean },
+    defaultOpen: { type: Boolean },
+    open: { type: Boolean },
+    delayDuration: { default: 0 },
+    disableHoverableContent: { type: Boolean },
+    disableClosingTrigger: { type: Boolean },
+    disabled: { type: Boolean },
+    ignoreNonKeyboardFocus: { type: Boolean },
+    forceMount: { type: Boolean },
+    ariaLabel: {},
+    asChild: { type: Boolean },
+    as: {},
+    side: {},
+    sideOffset: { default: 12 },
+    align: {},
+    alignOffset: {},
+    avoidCollisions: { type: Boolean },
+    collisionBoundary: {},
+    collisionPadding: {},
+    arrowPadding: {},
+    sticky: {},
+    hideWhenDetached: { type: Boolean }
+  },
+  emits: ["update:open"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const forwarded = index.xe(props, emits);
+    const isOpen = Mo.ref(props.defaultOpen);
+    function close() {
+      isOpen.value = false;
+    }
+    return (_ctx, _cache) => {
+      return Mo.openBlock(), Mo.createBlock(Mo.unref(index.Lg), null, {
+        default: Mo.withCtx(() => [
+          Mo.createVNode(Mo.unref(index.zg), Mo.mergeProps(Mo.unref(forwarded), {
+            open: props.open || isOpen.value,
+            "onUpdate:open": _cache[0] || (_cache[0] = (state) => isOpen.value = state)
+          }), {
+            default: Mo.withCtx(() => [
+              Mo.createVNode(Mo.unref(index.Kg), { "as-child": "" }, {
+                default: Mo.withCtx(() => [
+                  Mo.renderSlot(_ctx.$slots, "default", {}, void 0, true)
+                ]),
+                _: 3
+              }),
+              Mo.createVNode(Mo.unref(index.jg), { class: "celeste-tooltip-portal" }, {
+                default: Mo.withCtx(() => [
+                  Mo.createVNode(Mo.unref(index.Hg), Mo.mergeProps({ ...Mo.unref(forwarded), ..._ctx.$attrs }, {
+                    size: _ctx.size,
+                    variant: _ctx.variant,
+                    class: Mo.unref(clsx.clsx)("celeste-tooltip-content", props.class)
+                  }), {
+                    default: Mo.withCtx(() => [
+                      _ctx.icon ? (Mo.openBlock(), Mo.createElementBlock("i", {
+                        key: 0,
+                        class: Mo.normalizeClass(`celeste-tooltip-content-icon ${_ctx.icon}`)
+                      }, null, 2)) : Mo.createCommentVNode("", true),
+                      Mo.createElementVNode("div", _hoisted_1, [
+                        _ctx.title ? (Mo.openBlock(), Mo.createElementBlock("span", _hoisted_2, Mo.toDisplayString(_ctx.title), 1)) : Mo.createCommentVNode("", true),
+                        _ctx.description ? (Mo.openBlock(), Mo.createElementBlock("span", _hoisted_3, Mo.toDisplayString(_ctx.description), 1)) : Mo.createCommentVNode("", true)
+                      ]),
+                      _ctx.dismissible ? (Mo.openBlock(), Mo.createBlock(compactButton, {
+                        key: 1,
+                        variant: "ghost",
+                        icon: "i-celeste-close-line",
+                        onClick: close
+                      })) : Mo.createCommentVNode("", true),
+                      Mo.createVNode(Mo.unref(index.Wg), { "as-child": "" }, {
+                        default: Mo.withCtx(() => _cache[1] || (_cache[1] = [
+                          Mo.createElementVNode("span", { class: "celeste-tooltip-content-arrow" }, null, -1)
+                        ])),
+                        _: 1
+                      })
+                    ]),
+                    _: 1
+                  }, 16, ["size", "variant", "class"])
+                ]),
+                _: 1
+              })
+            ]),
+            _: 3
+          }, 16, ["open"])
+        ]),
+        _: 3
+      });
+    };
+  }
+});
+const Tooltip = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["__scopeId", "data-v-0dc4a40e"]]);
+module.exports = Tooltip;

package/dist/cjs/use-color-model.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const useColorModel = require("./chunks/use-color-model.js");
+require("vue");
+exports.ColorPickerEmits = useColorModel.ColorPickerEmits;
+exports.defineColorModel = useColorModel.defineColorModel;

package/dist/cjs/use-delegated-props.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Mo = require("vue");
+function useDelegatedProps(props, excludeKeys = ["class"]) {
+  return Mo.computed(() => {
+    const keysToExclude = Array.isArray(excludeKeys) ? excludeKeys : [excludeKeys];
+    const delegated = { ...props };
+    keysToExclude.forEach((key) => {
+      delete delegated[key];
+    });
+    return delegated;
+  });
+}
+exports.useDelegatedProps = useDelegatedProps;

package/dist/cjs/use-user-select.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Mo = require("vue");
+function useUserPageSelection() {
+  const isDisabled = Mo.ref(false);
+  let styleElement = null;
+  const preventPageUserSelect = () => {
+    if (!styleElement) {
+      styleElement = document.createElement("style");
+      styleElement.textContent = "body > * { user-select: none; }";
+      document.head.appendChild(styleElement);
+      isDisabled.value = true;
+    }
+  };
+  const allowPageUserSelect = () => {
+    if (styleElement) {
+      styleElement.remove();
+      styleElement = null;
+      isDisabled.value = false;
+    }
+  };
+  const togglePageUserSelect = () => {
+    if (styleElement) {
+      allowPageUserSelect();
+      return;
+    }
+    preventPageUserSelect();
+  };
+  Mo.onUnmounted(() => {
+    allowPageUserSelect();
+  });
+  return {
+    isDisabled: Mo.readonly(isDisabled),
+    togglePageUserSelect,
+    preventPageUserSelect,
+    allowPageUserSelect
+  };
+}
+exports.useUserPageSelection = useUserPageSelection;

package/dist/components/alert/alert.d.ts

@@ -0,0 +1,30 @@
+import { HTMLAttributes } from 'vue';
+export interface AlertProps {
+    class?: HTMLAttributes['class'];
+    size?: 'xs' | 'sm' | 'lg';
+    variant?: 'fill' | 'light' | 'lighter' | 'stroke';
+    state?: 'information' | 'success' | 'warning' | 'error' | 'feature';
+    dismissable?: boolean;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<AlertProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    dismiss: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<AlertProps> & Readonly<{
+    onDismiss?: ((...args: any[]) => any) | undefined;
+}>, {
+    size: "xs" | "sm" | "lg";
+    variant: "fill" | "light" | "lighter" | "stroke";
+    state: "information" | "success" | "warning" | "error" | "feature";
+    dismissable: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>, {
+    default?(_: {}): any;
+    title?(_: {}): any;
+    description?(_: {}): any;
+    primary?(_: {}): any;
+    secondary?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,2 @@
+export * from './alert';
+export { default as Alert } from './alert';

package/dist/components/badge/badge.d.ts

@@ -0,0 +1,17 @@
+import { HTMLAttributes } from 'vue';
+export interface BadgeProps {
+    size?: 'sm' | 'md';
+    variant?: 'fill' | 'light' | 'lighter' | 'stroke';
+    type?: 'basic' | 'dot' | 'leading-icon' | 'trailing-icon';
+    state?: 'faded' | 'information' | 'warning' | 'error' | 'success' | 'away' | 'feature' | 'verified' | 'highlighted' | 'stable';
+    disabled?: boolean;
+    icon?: string;
+    label?: string;
+    class?: HTMLAttributes['class'];
+}
+declare const _default: import('vue').DefineComponent<BadgeProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<BadgeProps> & Readonly<{}>, {
+    size: "sm" | "md";
+    variant: "fill" | "light" | "lighter" | "stroke";
+    type: "basic" | "dot" | "leading-icon" | "trailing-icon";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,4 @@
+export * from './badge';
+export { default as Badge } from './badge';
+export * from './status-badge';
+export { default as StatusBadge } from './status-badge';

package/dist/components/badge/status-badge.d.ts

@@ -0,0 +1,13 @@
+import { HTMLAttributes } from 'vue';
+export interface StatusBadgeProps {
+    variant?: 'stroke' | 'light';
+    dotted?: boolean;
+    state?: 'success' | 'warning' | 'error' | 'faded';
+    label: string;
+    class?: HTMLAttributes['class'];
+}
+declare const _default: import('vue').DefineComponent<StatusBadgeProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<StatusBadgeProps> & Readonly<{}>, {
+    variant: "stroke" | "light";
+    state: "success" | "warning" | "error" | "faded";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/components/button/button.d.ts

@@ -0,0 +1,22 @@
+import { HTMLAttributes } from 'vue';
+import { PrimitiveProps } from 'radix-vue';
+export interface ButtonProps extends PrimitiveProps {
+    class?: HTMLAttributes['class'];
+    size?: 'xxs' | 'xs' | 'sm' | 'md';
+    intent?: 'primary' | 'neutral' | 'error';
+    variant?: 'fill' | 'stroke' | 'lighter' | 'ghost';
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<ButtonProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ButtonProps> & Readonly<{}>, {
+    size: "xxs" | "xs" | "sm" | "md";
+    variant: "fill" | "stroke" | "lighter" | "ghost";
+    intent: "primary" | "neutral" | "error";
+    as: import('radix-vue').AsTag | import('vue').Component;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/button/compact-button.d.ts

@@ -0,0 +1,15 @@
+import { HTMLAttributes } from 'vue';
+import { PrimitiveProps } from 'radix-vue';
+export interface CompactButtonProps extends PrimitiveProps {
+    class?: HTMLAttributes['class'];
+    icon: string;
+    size?: 'lg' | 'md';
+    rounded?: boolean;
+    variant?: 'stroke' | 'white' | 'ghost';
+}
+declare const _default: import('vue').DefineComponent<CompactButtonProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<CompactButtonProps> & Readonly<{}>, {
+    size: "lg" | "md";
+    variant: "stroke" | "white" | "ghost";
+    as: import('radix-vue').AsTag | import('vue').Component;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/button/fancy-button.d.ts

@@ -0,0 +1,20 @@
+import { HTMLAttributes } from 'vue';
+import { PrimitiveProps } from 'radix-vue';
+export interface FancyButtonProps extends PrimitiveProps {
+    class?: HTMLAttributes['class'];
+    size?: 'xs' | 'sm' | 'md';
+    intent?: 'primary' | 'neutral' | 'error' | 'basic';
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<FancyButtonProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<FancyButtonProps> & Readonly<{}>, {
+    size: "xs" | "sm" | "md";
+    intent: "primary" | "neutral" | "error" | "basic";
+    as: import('radix-vue').AsTag | import('vue').Component;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,10 @@
+export * from './button';
+export { default as Button } from './button';
+export * from './compact-button';
+export { default as CompactButton } from './compact-button';
+export * from './fancy-button';
+export { default as FancyButton } from './fancy-button';
+export * from './link-button';
+export { default as LinkButton } from './link-button';
+export * from './social-button';
+export { default as SocialButton } from './social-button';