@ui-sdk/vue 0.0.0-stage → 0.1.0-beta.1

package/dist/preferences.js

@@ -0,0 +1,102 @@
+// src/preferences.ts
+import { preferencesScript } from "@ui-sdk/core";
+import {
+  computed,
+  defineComponent,
+  h,
+  onMounted,
+  onScopeDispose,
+  shallowRef,
+  watch
+} from "vue";
+var Preferences = defineComponent({
+  name: "Preferences",
+  props: {
+    /** The preferences to show, from `createPreference` or `createColorScheme`. */
+    preferences: {
+      type: Array,
+      required: true
+    },
+    /** The nonce your Content Security Policy gives inline scripts. */
+    nonce: String
+  },
+  slots: Object,
+  setup(props, { slots }) {
+    const values = shallowRef(
+      props.preferences.map((preference) => preference.initialState.value)
+    );
+    const mounted = shallowRef(false);
+    const element = shallowRef();
+    let stop = () => {
+    };
+    const follow = (list) => {
+      stop();
+      const read = () => {
+        values.value = list.map((preference) => preference.get().value);
+        for (const preference of list) {
+          ;
+          (preference.global ? document.documentElement : element.value)?.setAttribute(preference.attribute, preference.get().value);
+        }
+      };
+      const stops = list.map((preference) => preference.subscribe(read));
+      read();
+      stop = () => stops.forEach((each) => each());
+    };
+    onMounted(() => {
+      mounted.value = true;
+      follow(props.preferences);
+    });
+    watch(
+      () => props.preferences,
+      (list, previous) => {
+        const same = list.length === previous.length && list.every((preference, index) => preference === previous[index]);
+        if (mounted.value && !same) {
+          follow(list);
+        }
+      }
+    );
+    onScopeDispose(() => stop());
+    const attributes = computed(() => {
+      const shown = {};
+      props.preferences.forEach((preference, index) => {
+        if (!preference.global) {
+          shown[preference.attribute] = values.value[index] ?? preference.initialState.value;
+        }
+      });
+      return shown;
+    });
+    return () => h(
+      "div",
+      {
+        "data-slot": "preferences",
+        ref: element,
+        ...attributes.value,
+        // The script changes these attributes before hydration, so they may differ from the server's HTML.
+        "data-allow-mismatch": "attribute",
+        style: { display: "contents" }
+      },
+      [
+        mounted.value ? null : h("script", {
+          nonce: props.nonce,
+          innerHTML: preferencesScript(props.preferences)
+        }),
+        slots.default?.()
+      ]
+    );
+  }
+});
+function usePreference(preference) {
+  const state = shallowRef(preference.initialState);
+  let stop = () => {
+  };
+  onMounted(() => {
+    stop = preference.subscribe(() => state.value = preference.get());
+    state.value = preference.get();
+  });
+  onScopeDispose(() => stop());
+  return computed(() => state.value);
+}
+export {
+  Preferences,
+  usePreference
+};

package/dist/primitive.d.ts

@@ -0,0 +1,2 @@
+export { createParts, type Parts } from "./create-parts.js";
+export { usePart, usePrimitive, type PartElement, type PartSlots, type PrimitiveHandle, } from "./use-primitive.js";

package/dist/primitive.js

@@ -0,0 +1,11 @@
+// src/primitive.ts
+import { createParts } from "./create-parts.js";
+import {
+  usePart,
+  usePrimitive
+} from "./use-primitive.js";
+export {
+  createParts,
+  usePart,
+  usePrimitive
+};

package/dist/progress.d.ts

@@ -0,0 +1,41 @@
+import { type PartSlots } from "./use-primitive.js";
+/**
+ * The root, which is the progressbar.
+ * @stable
+ */
+declare const Progress: import("./create-parts.js").ElementPart<new (props: Omit<import("@ui-sdk/core").OptionsOf<import("@ui-sdk/core/progress").ProgressPrimitive> & import("@ui-sdk/core/renderer").BaseSlotProps, never> & {} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps) => import("vue").CreateComponentPublicInstanceWithMixins<Omit<import("@ui-sdk/core").OptionsOf<import("@ui-sdk/core/progress").ProgressPrimitive> & import("@ui-sdk/core/renderer").BaseSlotProps, never> & {}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {}, import("vue").PublicProps, {}, false, {}, import("./use-primitive.js").StateSlots<NoInfer<import("@ui-sdk/core/progress").ProgressState>>, {}, {}, string, {}, any, import("vue").ComponentProvideOptions, {
+    P: {};
+    B: {};
+    D: {};
+    C: {};
+    M: {};
+    Defaults: {};
+}, Omit<import("@ui-sdk/core").OptionsOf<import("@ui-sdk/core/progress").ProgressPrimitive> & import("@ui-sdk/core/renderer").BaseSlotProps, never> & {}, {}, {}, {}, {}, {}>, "div">;
+/**
+ * The rail the indicator fills.
+ * @stable
+ */
+declare const ProgressTrack: Pick<import("vue").DefineSetupFnComponent<Omit<import("@ui-sdk/core/renderer").BaseSlotProps, never>, {} & {}, import("./use-primitive.js").StateSlots<NoInfer<import("@ui-sdk/core/progress").ProgressState>>>, never> & import("./create-parts.js").ElementConstructor<import("vue").DefineSetupFnComponent<Omit<import("@ui-sdk/core/renderer").BaseSlotProps, never>, {} & {}, import("./use-primitive.js").StateSlots<NoInfer<import("@ui-sdk/core/progress").ProgressState>>>, "div">;
+/**
+ * The filled part of the track, as wide as the value.
+ * @stable
+ */
+declare const ProgressIndicator: Pick<import("vue").DefineSetupFnComponent<Omit<import("@ui-sdk/core/renderer").BaseSlotProps, never>, {} & {}, import("./use-primitive.js").StateSlots<NoInfer<import("@ui-sdk/core/progress").ProgressState>>>, never> & import("./create-parts.js").ElementConstructor<import("vue").DefineSetupFnComponent<Omit<import("@ui-sdk/core/renderer").BaseSlotProps, never>, {} & {}, import("./use-primitive.js").StateSlots<NoInfer<import("@ui-sdk/core/progress").ProgressState>>>, "div">;
+/**
+ * Names the progress bar.
+ * @stable
+ */
+declare const ProgressLabel: Pick<import("vue").DefineSetupFnComponent<Omit<import("@ui-sdk/core/renderer").BaseSlotProps, never>, {} & {}, import("./use-primitive.js").StateSlots<NoInfer<import("@ui-sdk/core/progress").ProgressState>>>, never> & import("./create-parts.js").ElementConstructor<import("vue").DefineSetupFnComponent<Omit<import("@ui-sdk/core/renderer").BaseSlotProps, never>, {} & {}, import("./use-primitive.js").StateSlots<NoInfer<import("@ui-sdk/core/progress").ProgressState>>>, "span">;
+/**
+ * The formatted value, like "40%". Content replaces it.
+ * @stable
+ */
+declare const ProgressValue: import("./create-parts.js").ElementPart<import("vue").DefineComponent<{}, (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | null) & {
+    state: NoInfer<import("@ui-sdk/core/progress").ProgressValueState>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, PartSlots<import("@ui-sdk/core/progress").ProgressPrimitive, "value">, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, "span">;
+export type { GaugeLabelDetails, NumberFormat, ProgressOptions, ProgressPrimitive, ProgressState, ProgressStatus, ProgressValueState, } from "@ui-sdk/core/progress";
+export { Progress, ProgressIndicator, ProgressLabel, ProgressTrack, ProgressValue, };

package/dist/progress.js

@@ -0,0 +1,37 @@
+// src/progress.ts
+import { progress } from "@ui-sdk/core/progress";
+import { defineComponent } from "vue";
+import { slotContent } from "./children.js";
+import { createParts, withElement } from "./create-parts.js";
+import { usePart } from "./use-primitive.js";
+var parts = createParts(progress, {
+  root: "div",
+  track: "div",
+  indicator: "div",
+  label: "span"
+});
+var Progress = parts.Root;
+var ProgressTrack = parts.Track;
+var ProgressIndicator = parts.Indicator;
+var ProgressLabel = parts.Label;
+var ProgressValue = withElement(
+  "span",
+  defineComponent({
+    name: "ProgressValue",
+    inheritAttrs: false,
+    slots: Object,
+    setup(_, { slots }) {
+      return usePart(progress, "value", void 0, void 0, {
+        tag: "span",
+        children: (state) => slotContent(slots.default, { state }) ?? state.text
+      });
+    }
+  })
+);
+export {
+  Progress,
+  ProgressIndicator,
+  ProgressLabel,
+  ProgressTrack,
+  ProgressValue
+};

package/dist/radio.d.ts

@@ -0,0 +1,164 @@
+import type { ChangeDetails } from "@ui-sdk/core";
+import { type RadioGroupController, type RadioGroupValueChangeReason } from "@ui-sdk/core/radio";
+import { type PropType } from "vue";
+import { type PartSlots } from "./use-primitive.js";
+/**
+ * Radios that share one value, with one tab stop and arrow keys between them.
+ * @stable
+ */
+declare const RadioGroup: import("./create-parts.js").ElementPart<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    value: {
+        type: PropType<string | null>;
+        default: undefined;
+    };
+    modelValue: {
+        type: PropType<string | null>;
+        default: undefined;
+    };
+    defaultValue: {
+        type: PropType<string | null>;
+        default: undefined;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    readOnly: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    required: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    name: StringConstructor;
+    form: StringConstructor;
+    loop: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    controller: PropType<RadioGroupController>;
+    debug: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+}>, (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | null) & {
+    state: NoInfer<{
+        value: string | null;
+        disabled: boolean;
+        readOnly: boolean;
+        required: boolean;
+    }>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:value": (_value: string | null) => true;
+    "update:modelValue": (_value: string | null) => true;
+    valueChange: (_value: string | null, _details: ChangeDetails<RadioGroupValueChangeReason>) => true;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: PropType<string | null>;
+        default: undefined;
+    };
+    modelValue: {
+        type: PropType<string | null>;
+        default: undefined;
+    };
+    defaultValue: {
+        type: PropType<string | null>;
+        default: undefined;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    readOnly: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    required: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    name: StringConstructor;
+    form: StringConstructor;
+    loop: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    controller: PropType<RadioGroupController>;
+    debug: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((_value: string | null) => any) | undefined;
+    "onUpdate:value"?: ((_value: string | null) => any) | undefined;
+    onValueChange?: ((_value: string | null, _details: ChangeDetails<RadioGroupValueChangeReason>) => any) | undefined;
+}>, {
+    value: string | null;
+    disabled: boolean;
+    debug: boolean;
+    defaultValue: string | null;
+    required: boolean;
+    loop: boolean;
+    readOnly: boolean;
+    modelValue: string | null;
+}, PartSlots<import("@ui-sdk/core/radio").RadioGroupPrimitive, "group">, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, "div">;
+/**
+ * A radio and the hidden native radio that takes part in the form.
+ * @stable
+ */
+declare const Radio: import("./create-parts.js").ElementPart<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    value: {
+        type: StringConstructor;
+        required: true;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+}>, () => (import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | null)[], {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: StringConstructor;
+        required: true;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    disabled: boolean;
+}, PartSlots<import("@ui-sdk/core/radio").RadioGroupPrimitive, "root">, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, "button">;
+/**
+ * The dot inside the radio. Rendered while it's checked, or always with `keepMounted`.
+ * @stable
+ */
+declare const RadioIndicator: import("./create-parts.js").ElementPart<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    keepMounted: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+}>, (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | null) & {
+    state: NoInfer<import("@ui-sdk/core/radio").RadioState>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    keepMounted: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    keepMounted: boolean;
+}, PartSlots<import("@ui-sdk/core/radio").RadioGroupPrimitive, "indicator">, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, "span">;
+export { createRadioGroupController } from "@ui-sdk/core/radio";
+export type { RadioGroupApi, RadioGroupChangeOptions, RadioGroupController, RadioGroupOptions, RadioGroupPrimitive, RadioGroupState, RadioGroupValueChangeReason, RadioIndicatorProps, RadioIndicatorState, RadioProps, RadioState, } from "@ui-sdk/core/radio";
+export { Radio, RadioGroup, RadioIndicator };

package/dist/radio.js

@@ -0,0 +1,145 @@
+// src/radio.ts
+import {
+  radioGroup as radioGroupPrimitive
+} from "@ui-sdk/core/radio";
+import {
+  defineComponent,
+  h,
+  inject,
+  provide
+} from "vue";
+import { withElement } from "./create-parts.js";
+import { FieldKey, useFieldControl } from "./field-context.js";
+import {
+  optionalBoolean,
+  orModel,
+  provideProps,
+  usePart,
+  usePrimitive,
+  useScope
+} from "./use-primitive.js";
+import { readOnlyOf } from "./text-control.js";
+import { createRadioGroupController } from "@ui-sdk/core/radio";
+var GroupFieldKey = /* @__PURE__ */ Symbol("radio-group-field");
+var RadioGroup = withElement(
+  "div",
+  defineComponent({
+    name: "RadioGroup",
+    inheritAttrs: false,
+    props: {
+      value: { type: String, default: void 0 },
+      modelValue: {
+        type: String,
+        default: void 0
+      },
+      defaultValue: {
+        type: String,
+        default: void 0
+      },
+      disabled: optionalBoolean,
+      readOnly: optionalBoolean,
+      required: optionalBoolean,
+      name: String,
+      form: String,
+      loop: optionalBoolean,
+      controller: Object,
+      debug: optionalBoolean
+    },
+    emits: {
+      "update:value": (_value) => true,
+      "update:modelValue": (_value) => true,
+      valueChange: (_value, _details) => true
+    },
+    slots: Object,
+    setup(props, { attrs, emit }) {
+      provide(GroupFieldKey, inject(FieldKey, null));
+      const field = useFieldControl();
+      const group = usePrimitive(radioGroupPrimitive, () => ({
+        value: orModel(props.value, props.modelValue),
+        defaultValue: props.defaultValue,
+        disabled: props.disabled || field?.disabled(),
+        readOnly: readOnlyOf(props, attrs),
+        required: props.required,
+        name: props.name ?? field?.name(),
+        form: props.form,
+        loop: props.loop,
+        controller: props.controller,
+        debug: props.debug,
+        onValueChange: (value, details) => {
+          emit("valueChange", value, details);
+          if (details.canceled) {
+            return;
+          }
+          emit("update:value", value);
+          emit("update:modelValue", value);
+        }
+      }));
+      return usePart(group, "group", void 0, void 0, {
+        tag: "div",
+        extend: field?.props
+      });
+    }
+  })
+);
+var Radio = withElement(
+  "button",
+  defineComponent({
+    name: "Radio",
+    inheritAttrs: false,
+    props: {
+      value: { type: String, required: true },
+      disabled: optionalBoolean
+    },
+    slots: Object,
+    setup(props) {
+      const group = useScope(radioGroupPrimitive)?.handle;
+      if (!group) {
+        throw new Error("Radio group parts must be used inside <RadioGroup>.");
+      }
+      const nearest = inject(FieldKey, null);
+      const field = nearest && nearest !== inject(GroupFieldKey, null) ? useFieldControl() : null;
+      const item = () => ({
+        value: props.value,
+        disabled: props.disabled || field?.disabled()
+      });
+      provideProps(radioGroupPrimitive, "root", item);
+      const radio = usePart(group, "root", item, void 0, {
+        tag: "button",
+        extend: field?.props
+      });
+      return () => [radio(), h("input", group.slot("input", item()))];
+    }
+  })
+);
+var RadioIndicator = withElement(
+  "span",
+  defineComponent({
+    name: "RadioIndicator",
+    inheritAttrs: false,
+    props: { keepMounted: optionalBoolean },
+    slots: Object,
+    setup(props) {
+      const radio = useScope(radioGroupPrimitive)?.around.root;
+      if (!radio) {
+        throw new Error("RadioIndicator must be used inside <Radio>.");
+      }
+      const indicator = () => ({
+        value: String(radio().value),
+        keepMounted: props.keepMounted
+      });
+      return usePart(
+        radioGroupPrimitive,
+        "indicator",
+        indicator,
+        void 0,
+        "span"
+      );
+    }
+  })
+);
+export {
+  Radio,
+  RadioGroup,
+  RadioIndicator,
+  createRadioGroupController
+};

package/dist/rating.d.ts

@@ -0,0 +1,149 @@
+import type { ChangeDetails } from "@ui-sdk/core";
+import { type RatingController, type RatingState, type RatingValueChangeReason } from "@ui-sdk/core/rating";
+import { type PropType } from "vue";
+import { type PartSlots } from "./use-primitive.js";
+/**
+ * A score picked from a row of stars, a radio per star or half star, with a
+ * preview while a pointer moves over them. Its default slot renders once per star.
+ * @experimental
+ */
+declare const Rating: import("./create-parts.js").ElementPart<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    value: {
+        type: PropType<number | null>;
+        default: undefined;
+    };
+    modelValue: {
+        type: PropType<number | null>;
+        default: undefined;
+    };
+    defaultValue: {
+        type: PropType<number | null>;
+        default: undefined;
+    };
+    max: {
+        type: NumberConstructor;
+        default: number;
+    };
+    step: {
+        type: NumberConstructor;
+        default: number;
+    };
+    deselectable: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    readOnly: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    required: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    name: StringConstructor;
+    form: StringConstructor;
+    loop: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    getValueLabel: PropType<(value: number, max: number) => string>;
+    controller: PropType<RatingController>;
+    debug: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+}>, (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | null) & {
+    state: NoInfer<RatingState>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:value": (_value: number | null) => true;
+    "update:modelValue": (_value: number | null) => true;
+    valueChange: (_value: number | null, _details: ChangeDetails<RatingValueChangeReason>) => true;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: PropType<number | null>;
+        default: undefined;
+    };
+    modelValue: {
+        type: PropType<number | null>;
+        default: undefined;
+    };
+    defaultValue: {
+        type: PropType<number | null>;
+        default: undefined;
+    };
+    max: {
+        type: NumberConstructor;
+        default: number;
+    };
+    step: {
+        type: NumberConstructor;
+        default: number;
+    };
+    deselectable: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    readOnly: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    required: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    name: StringConstructor;
+    form: StringConstructor;
+    loop: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    getValueLabel: PropType<(value: number, max: number) => string>;
+    controller: PropType<RatingController>;
+    debug: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((_value: number | null) => any) | undefined;
+    "onUpdate:value"?: ((_value: number | null) => any) | undefined;
+    onValueChange?: ((_value: number | null, _details: ChangeDetails<RatingValueChangeReason>) => any) | undefined;
+}>, {
+    value: number | null;
+    disabled: boolean;
+    debug: boolean;
+    defaultValue: number | null;
+    required: boolean;
+    loop: boolean;
+    step: number;
+    max: number;
+    readOnly: boolean;
+    deselectable: boolean;
+    modelValue: number | null;
+}, PartSlots<import("@ui-sdk/core/rating").RatingPrimitive, "root">, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, "div">;
+/**
+ * One star. Put its icon inside: the slot gets how full it is, and the radios
+ * that pick its score sit over it.
+ * @experimental
+ */
+declare const RatingItem: import("./create-parts.js").ElementPart<import("vue").DefineComponent<{}, (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | null) & {
+    state: NoInfer<import("@ui-sdk/core/rating").RatingItemState>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, PartSlots<import("@ui-sdk/core/rating").RatingPrimitive, "item">, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, "span">;
+export { createRatingController } from "@ui-sdk/core/rating";
+export type { RatingApi, RatingChangeOptions, RatingController, RatingItemProps, RatingItemState, RatingOptions, RatingPrimitive, RatingState, RatingValueChangeReason, } from "@ui-sdk/core/rating";
+export { Rating, RatingItem };