@una-ui/nuxt 1.0.0-alpha.1 → 1.0.0-alpha.10

package/dist/runtime/components/pin-input/PinInput.vue

@@ -0,0 +1,139 @@
+<script>
+
+</script>
+
+<script setup>
+import { reactivePick } from "@vueuse/core";
+import { PinInputRoot, useForwardPropsEmits } from "reka-ui";
+import { computed } from "vue";
+import { cn, randomId } from "../../utils";
+import PinInputGroup from "./PinInputGroup.vue";
+import PinInputSeparator from "./PinInputSeparator.vue";
+import PinInputSlot from "./PinInputSlot.vue";
+const props = defineProps({
+  defaultValue: { type: Array, required: false },
+  maxLength: { type: Number, required: false },
+  separator: { type: [Boolean, String], required: false, default: false },
+  groupBy: { type: Number, required: false, default: 0 },
+  _pinInputGroup: { type: Object, required: false },
+  _pinInputSeparator: { type: Object, required: false },
+  _pinInputSlot: { type: Object, required: false },
+  una: { type: Object, required: false },
+  modelValue: { type: null, required: false },
+  placeholder: { type: String, required: false },
+  mask: { type: Boolean, required: false },
+  otp: { type: Boolean, required: false },
+  type: { type: null, required: false, default: "text" },
+  dir: { type: String, required: false },
+  disabled: { type: Boolean, required: false },
+  id: { type: String, required: false },
+  asChild: { type: Boolean, required: false },
+  as: { type: null, required: false },
+  name: { type: String, required: false },
+  required: { type: Boolean, required: false },
+  pinInput: { type: null, required: false, default: "outline-primary" },
+  status: { type: String, required: false },
+  class: { type: null, required: false },
+  size: { type: null, required: false, default: "md" }
+});
+const emits = defineEmits(["update:modelValue", "complete"]);
+const rootProps = reactivePick(props, [
+  "as",
+  "asChild",
+  "dir",
+  "defaultValue",
+  "disabled",
+  "id",
+  "mask",
+  "modelValue",
+  "name",
+  "otp",
+  "placeholder",
+  "type",
+  "required"
+]);
+const forwarded = useForwardPropsEmits(rootProps, emits);
+const id = computed(() => props.id ?? randomId("pin-input"));
+const separator = computed(() => {
+  if (props.separator === true) {
+    return "pin-input-separator-icon";
+  }
+  return props.separator;
+});
+const maxLength = computed(() => {
+  if (typeof props.maxLength !== "number") {
+    return props.modelValue?.length ?? 0;
+  }
+  return props.maxLength;
+});
+</script>
+
+<template>
+  <PinInputRoot
+    v-bind="forwarded"
+    :id
+    data-slot="pin-input"
+    :class="cn(
+  'pin-input',
+  props.una?.pinInput,
+  props.class
+)"
+    :size
+  >
+    <slot>
+      <template v-if="groupBy === 0">
+        <PinInputGroup
+          v-bind="_pinInputGroup"
+          :una
+        >
+          <slot name="group">
+            <template v-for="index in maxLength" :key="index">
+              <slot name="slot" :index="index - 1">
+                <PinInputSlot
+                  :index="index - 1"
+                  :una
+                  :status
+                  :pin-input
+                  v-bind="_pinInputSlot"
+                />
+              </slot>
+            </template>
+          </slot>
+        </PinInputGroup>
+      </template>
+
+      <template v-else>
+        <template v-for="(groupIndex) in Math.ceil(maxLength / groupBy)" :key="groupIndex">
+          <PinInputGroup
+            v-bind="_pinInputGroup"
+            :una
+          >
+            <slot name="group">
+              <template v-for="slotInGroup in Math.min(groupBy, maxLength - (groupIndex - 1) * groupBy)" :key="slotInGroup">
+                <slot name="slot" :index="(groupIndex - 1) * groupBy + slotInGroup - 1">
+                  <PinInputSlot
+                    :index="(groupIndex - 1) * groupBy + slotInGroup - 1"
+                    :una
+                    :pin-input
+                    :status
+                    v-bind="_pinInputSlot"
+                  />
+                </slot>
+              </template>
+            </slot>
+          </PinInputGroup>
+
+          <template v-if="separator !== false && (separator || $slots.separator) && groupIndex < Math.ceil(maxLength / groupBy)">
+            <PinInputSeparator
+              :icon="separator"
+              :una
+              v-bind="_pinInputSeparator"
+            >
+              <slot name="separator" />
+            </PinInputSeparator>
+          </template>
+        </template>
+      </template>
+    </slot>
+  </PinInputRoot>
+</template>

package/dist/runtime/components/pin-input/PinInput.vue.d.ts

@@ -0,0 +1,33 @@
+import type { NPinInputProps, PinInputType } from '../../types/index.js';
+declare const _default: <T extends PinInputType = "text">(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:modelValue"?: ((value: string[]) => any) | undefined;
+        readonly onComplete?: ((value: string[]) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onUpdate:modelValue" | "onComplete"> & NPinInputProps<T> & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {
+        default?: (props: {}) => any;
+    } & {
+        group?: (props: {}) => any;
+    } & {
+        slot?: (props: {
+            index: number;
+        }) => any;
+    } & {
+        group?: (props: {}) => any;
+    } & {
+        slot?: (props: {
+            index: number;
+        }) => any;
+    } & {
+        separator?: (props: {}) => any;
+    };
+    emit: ((evt: "update:modelValue", value: string[]) => void) & ((evt: "complete", value: string[]) => void);
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/runtime/components/pin-input/PinInputGroup.vue

@@ -0,0 +1,28 @@
+<script setup>
+import { reactiveOmit } from "@vueuse/core";
+import { Primitive, useForwardProps } from "reka-ui";
+import { cn } from "../../utils";
+const props = defineProps({
+  una: { type: Object, required: false },
+  asChild: { type: Boolean, required: false },
+  as: { type: null, required: false },
+  class: { type: null, required: false },
+  size: { type: null, required: false }
+});
+const delegatedProps = reactiveOmit(props, "class");
+const forwardedProps = useForwardProps(delegatedProps);
+</script>
+
+<template>
+  <Primitive
+    data-slot="pin-input-group"
+    v-bind="forwardedProps"
+    :class="cn(
+  'pin-input-group',
+  props.una?.pinInputGroup,
+  props.class
+)"
+  >
+    <slot />
+  </Primitive>
+</template>

package/dist/runtime/components/pin-input/PinInputGroup.vue.d.ts

@@ -0,0 +1,13 @@
+import type { NPinInputGroupProps } from '../../types/index.js';
+declare var __VLS_6: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_6) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<NPinInputGroupProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<NPinInputGroupProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/pin-input/PinInputSeparator.vue

@@ -0,0 +1,30 @@
+<script setup>
+import { Primitive, useForwardProps } from "reka-ui";
+import { cn } from "../../utils";
+import Icon from "../elements/Icon.vue";
+const props = defineProps({
+  icon: { type: String, required: false, default: "i-lucide-minus" },
+  una: { type: Object, required: false },
+  asChild: { type: Boolean, required: false },
+  as: { type: null, required: false },
+  class: { type: null, required: false },
+  size: { type: null, required: false }
+});
+const forwardedProps = useForwardProps(props);
+</script>
+
+<template>
+  <Primitive
+    data-slot="pin-input-separator"
+    v-bind="forwardedProps"
+    :class="cn(
+  'pin-input-separator',
+  props.una?.pinInputSeparator,
+  props.class
+)"
+  >
+    <slot>
+      <Icon :name="icon" />
+    </slot>
+  </Primitive>
+</template>

package/dist/runtime/components/pin-input/PinInputSeparator.vue.d.ts

@@ -0,0 +1,15 @@
+import type { NPinInputSeparatorProps } from '../../types/index.js';
+declare var __VLS_6: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_6) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<NPinInputSeparatorProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<NPinInputSeparatorProps> & Readonly<{}>, {
+    icon: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/pin-input/PinInputSlot.vue

@@ -0,0 +1,46 @@
+<script setup>
+import { reactiveOmit } from "@vueuse/core";
+import { PinInputInput, useForwardProps } from "reka-ui";
+import { computed } from "vue";
+import { cn } from "../../utils";
+const props = defineProps({
+  pinInput: { type: null, required: false, default: "outline-primary" },
+  status: { type: String, required: false },
+  una: { type: Object, required: false },
+  index: { type: Number, required: true },
+  disabled: { type: Boolean, required: false },
+  asChild: { type: Boolean, required: false },
+  as: { type: null, required: false },
+  icon: { type: String, required: false },
+  class: { type: null, required: false },
+  size: { type: null, required: false }
+});
+const delegatedProps = reactiveOmit(props, "class");
+const forwardedProps = useForwardProps(delegatedProps);
+const statusClassVariants = computed(() => {
+  const input = {
+    info: "input-status-info pin-input-solid-info input-status-ring",
+    success: "input-status-success pin-input-solid-success input-status-ring",
+    warning: "input-status-warning pin-input-solid-warning input-status-ring",
+    error: "input-status-error pin-input-solid-error input-status-ring",
+    default: void 0
+  };
+  return {
+    input: input[props.status ?? "default"]
+  };
+});
+</script>
+
+<template>
+  <PinInputInput
+    data-slot="pin-input-slot"
+    v-bind="forwardedProps"
+    :class="cn(
+  'pin-input-slot',
+  props.una?.pinInputSlot,
+  props.class,
+  statusClassVariants.input
+)"
+    :pin-input="statusClassVariants.input === void 0 && props.pinInput"
+  />
+</template>

package/dist/runtime/components/pin-input/PinInputSlot.vue.d.ts

@@ -0,0 +1,5 @@
+import type { NPinInputSlotProps } from '../../types/index.js';
+declare const _default: import("vue").DefineComponent<NPinInputSlotProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<NPinInputSlotProps> & Readonly<{}>, {
+    pinInput: import("vue").HTMLAttributes["class"];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/components/resizable/ResizableHandle.vue

@@ -12,6 +12,7 @@ const props = defineProps({
   hitAreaMargins: { type: Object, required: false },
   tabindex: { type: Number, required: false },
   disabled: { type: Boolean, required: false },
+  nonce: { type: String, required: false },
   asChild: { type: Boolean, required: false },
   as: { type: null, required: false },
   class: { type: null, required: false }

package/dist/runtime/components/resizable/ResizablePanel.vue.d.ts

@@ -1,11 +1,5 @@
 import type { NResizablePanelProps } from '../../types/index.js';
-declare var __VLS_6: {
-    isCollapsed: boolean;
-    isExpanded: boolean;
-    collapse: () => void;
-    expand: () => void;
-    resize: (size: number) => void;
-};
+declare var __VLS_6: any;
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_6) => any;
 };

package/dist/runtime/components/resizable/ResizablePanelGroup.vue.d.ts

@@ -1,7 +1,5 @@
 import type { NResizablePanelGroupProps } from '../../types/index.js';
-declare var __VLS_6: {
-    layout: number[];
-};
+declare var __VLS_6: any;
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_6) => any;
 };

package/dist/runtime/components/sheet/Sheet.vue.d.ts

@@ -1,6 +1,6 @@
 import type { NSheetProps } from '../../types/index.js';
 declare var __VLS_6: {}, __VLS_11: {
-    open: boolean;
+    open: any;
 }, __VLS_26: {}, __VLS_31: {}, __VLS_36: {}, __VLS_41: {}, __VLS_43: {}, __VLS_45: {}, __VLS_50: {};
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_6) => any;

package/dist/runtime/components/sheet/SheetContent.vue

@@ -19,7 +19,6 @@ const props = defineProps({
   _sheetPortal: { type: Object, required: false },
   una: { type: Object, required: false },
   forceMount: { type: Boolean, required: false },
-  trapFocus: { type: Boolean, required: false },
   disableOutsidePointerEvents: { type: Boolean, required: false },
   asChild: { type: Boolean, required: false },
   as: { type: null, required: false }
@@ -55,7 +54,12 @@ const contentEvents = computed(() => {
       data-slot="sheet-content"
       v-bind="{ ...forwarded, ...$attrs }"
       :sheet
-      :class="cn('sheet-content', props.una?.sheetContent, props.class)"
+      :class="cn(
+  'data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:duration-300 data-[state=open]:duration-500',
+  'sheet-content',
+  props.una?.sheetContent,
+  props.class
+)"
       v-on="contentEvents"
     >
       <slot />

package/dist/runtime/components/sheet/SheetOverlay.vue

@@ -15,7 +15,12 @@ const delegatedProps = reactiveOmit(props, "class");
 <template>
   <DialogOverlay
     data-slot="sheet-overlay"
-    :class="cn('dialog-overlay', props.una?.sheetOverlay, props.class)"
+    :class="cn(
+  'data-[state=closed]:animate-out data-[state=open]:animate-in data-[state=open]:fade-in-0 data-[state=closed]:fade-out-0',
+  'sheet-overlay',
+  props.una?.sheetOverlay,
+  props.class
+)"
     v-bind="delegatedProps"
   >
     <slot />

package/dist/runtime/components/sidebar/SidebarMenu.vue.d.ts

@@ -9,7 +9,7 @@ declare const _default: <T extends {
         default?: (props: {}) => any;
     } & {
         item?: (props: {
-            item: T;
+            item: any;
         }) => any;
     };
     emit: {};

package/dist/runtime/components/stepper/Stepper.vue

@@ -0,0 +1,163 @@
+<script setup>
+import { reactiveOmit } from "@vueuse/core";
+import { StepperRoot, useForwardPropsEmits } from "reka-ui";
+import { computed, useTemplateRef } from "vue";
+import { cn } from "../../utils";
+import Icon from "../elements/Icon.vue";
+import StepperContainer from "./StepperContainer.vue";
+import StepperDescription from "./StepperDescription.vue";
+import StepperHeader from "./StepperHeader.vue";
+import StepperIndicator from "./StepperIndicator.vue";
+import StepperItem from "./StepperItem.vue";
+import StepperSeparator from "./StepperSeparator.vue";
+import StepperTitle from "./StepperTitle.vue";
+import StepperTrigger from "./StepperTrigger.vue";
+import StepperWrapper from "./StepperWrapper.vue";
+const props = defineProps({
+  items: { type: Array, required: false },
+  stepper: { type: String, required: false, default: "solid-primary" },
+  _stepperItem: { type: Object, required: false },
+  _stepperTrigger: { type: Object, required: false },
+  _stepperSeparator: { type: Object, required: false },
+  _stepperTitle: { type: Object, required: false },
+  _stepperDescription: { type: Object, required: false },
+  _stepperIndicator: { type: Object, required: false },
+  _stepperHeader: { type: Object, required: false },
+  _stepperWrapper: { type: Object, required: false },
+  _stepperContainer: { type: Object, required: false },
+  una: { type: Object, required: false },
+  defaultValue: { type: Number, required: false },
+  orientation: { type: String, required: false, default: "horizontal" },
+  dir: { type: String, required: false },
+  modelValue: { type: Number, required: false },
+  linear: { type: Boolean, required: false },
+  asChild: { type: Boolean, required: false },
+  as: { type: null, required: false },
+  disabled: { type: Boolean, required: false },
+  class: { type: null, required: false },
+  size: { type: null, required: false }
+});
+const emits = defineEmits(["update:modelValue", "next", "prev"]);
+const modelValue = defineModel({ type: [String, Number] });
+const delegatedProps = reactiveOmit(props, [
+  "class",
+  "una"
+]);
+const forwarded = useForwardPropsEmits(delegatedProps, emits);
+const stepper = useTemplateRef("stepper");
+const currentStepIndex = computed({
+  get() {
+    const value = modelValue.value ?? props.defaultValue;
+    return (typeof value === "string" ? props.items?.findIndex((item) => item.value === value) : value) ?? 0;
+  },
+  set(value) {
+    modelValue.value = props.items?.[value]?.value ?? value;
+  }
+});
+const currentStep = computed(() => props.items?.[currentStepIndex.value]);
+const isEveryItemHasStep = computed(() => props.items?.every((item) => item.step));
+const hasNextStep = computed(() => currentStepIndex.value < props.items.length - 1);
+const hasPrevStep = computed(() => currentStepIndex.value > 0);
+defineExpose({
+  goToStep: (step) => {
+    currentStepIndex.value = step;
+    stepper.value?.goToStep(step);
+  },
+  nextStep: () => {
+    if (!hasNextStep.value)
+      return;
+    currentStepIndex.value += 1;
+    stepper.value?.nextStep();
+    emits("next", currentStep.value);
+  },
+  prevStep: () => {
+    if (!hasPrevStep.value)
+      return;
+    currentStepIndex.value -= 1;
+    stepper.value?.prevStep();
+    emits("prev", currentStep.value);
+  },
+  hasNext: () => hasNextStep.value,
+  hasPrev: () => hasPrevStep.value
+});
+</script>
+
+<template>
+  <StepperRoot
+    ref="stepper"
+    v-slot="slotProps"
+    v-bind="forwarded"
+    v-model="currentStepIndex"
+    :class="cn(
+  'stepper',
+  orientation === 'horizontal' && 'stepper-horizontal',
+  props.class
+)"
+    :una
+  >
+    <slot v-bind="slotProps">
+      <StepperWrapper :una v-bind="props._stepperWrapper" :orientation>
+        <slot name="wrapper" :items>
+          <StepperItem
+            v-for="(item, idx) in items"
+            :key="isEveryItemHasStep ? item.step : idx"
+            :step="isEveryItemHasStep ? item.step : idx"
+            :disabled="item.disabled ?? props.disabled"
+            :una
+            v-bind="props._stepperItem"
+            :orientation
+          >
+            <slot name="item" :item="item" :step="isEveryItemHasStep ? item.step : idx">
+              <StepperContainer :orientation :una v-bind="props._stepperContainer">
+                <StepperTrigger v-bind="props._stepperTrigger" :una :stepper="props.stepper" :size="size ?? item.size">
+                  <slot name="trigger" :item="item">
+                    <StepperIndicator
+                      v-slot="{ step }"
+                      v-bind="props._stepperIndicator"
+                      :una
+                      :size="size ?? item.size"
+                      :stepper="props.stepper"
+                    >
+                      <slot name="indicator" :item :step>
+                        <Icon v-if="item.icon" :name="item.icon" :size="size ?? item.size" />
+                        <template v-else>
+                          {{ idx + 1 }}
+                        </template>
+                      </slot>
+                    </StepperIndicator>
+                  </slot>
+                </StepperTrigger>
+                <StepperSeparator
+                  v-if="items && idx < items.length - 1"
+                  v-bind="props._stepperSeparator"
+                  :una
+                  :stepper="props.stepper"
+                  :orientation
+                />
+              </StepperContainer>
+              <StepperHeader :una v-bind="props._stepperHeader" :orientation>
+                <slot name="header" :item="item">
+                  <StepperTitle v-if="item.title" :una v-bind="props._stepperTitle" :size="size ?? item.size">
+                    <slot name="title" :item="item">
+                      {{ item.title }}
+                    </slot>
+                  </StepperTitle>
+                  <StepperDescription v-if="item.description" :una v-bind="props._stepperDescription" :size="size ?? item.size">
+                    <slot name="description" :item="item">
+                      {{ item.description }}
+                    </slot>
+                  </StepperDescription>
+                </slot>
+              </StepperHeader>
+            </slot>
+          </StepperItem>
+        </slot>
+      </StepperWrapper>
+      <slot
+        v-if="!!$slots.content || currentStep?.slot"
+        :name="currentStep?.slot ?? 'content'"
+        :item="currentStep"
+      />
+    </slot>
+  </StepperRoot>
+</template>

package/dist/runtime/components/stepper/Stepper.vue.d.ts

@@ -0,0 +1,62 @@
+import type { NStepperItemProps, NStepperProps } from '../../types/index.js';
+declare const _default: <T extends Partial<NStepperItemProps>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:modelValue"?: ((...args: unknown[]) => any) | undefined;
+        readonly onNext?: ((payload: T) => any) | undefined;
+        readonly onPrev?: ((payload: T) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onUpdate:modelValue" | "onNext" | "onPrev"> & (NStepperProps<T> & {
+        modelValue?: string | number;
+    }) & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{
+        goToStep: (step: number) => void;
+        nextStep: () => void;
+        prevStep: () => void;
+        hasNext: () => boolean;
+        hasPrev: () => boolean;
+    }>): void;
+    attrs: any;
+    slots: {
+        [x: string]: ((props: {
+            item: any;
+        }) => any) | undefined;
+    } & {
+        default?: (props: any) => any;
+    } & {
+        wrapper?: (props: {
+            items: any;
+        }) => any;
+    } & {
+        item?: (props: {
+            item: any;
+            step: any;
+        }) => any;
+    } & {
+        trigger?: (props: {
+            item: any;
+        }) => any;
+    } & {
+        indicator?: (props: {
+            item: any;
+            step: any;
+        }) => any;
+    } & {
+        header?: (props: {
+            item: any;
+        }) => any;
+    } & {
+        title?: (props: {
+            item: any;
+        }) => any;
+    } & {
+        description?: (props: {
+            item: any;
+        }) => any;
+    };
+    emit: (((evt: "update:modelValue", payload: number | undefined) => void) & ((evt: "next", payload: T) => void) & ((evt: "prev", payload: T) => void)) & ((evt: "update:modelValue", value: string | number | undefined) => void);
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/runtime/components/stepper/StepperContainer.vue

@@ -0,0 +1,21 @@
+<script setup>
+import { cn } from "../../utils";
+const props = defineProps({
+  una: { type: Object, required: false },
+  class: { type: null, required: false },
+  orientation: { type: String, required: false, default: "horizontal" }
+});
+</script>
+
+<template>
+  <div
+    :class="cn(
+  'stepper-container',
+  orientation === 'horizontal' && 'stepper-container-horizontal',
+  props.class,
+  props.una?.stepperContainer
+)"
+  >
+    <slot />
+  </div>
+</template>

package/dist/runtime/components/stepper/StepperContainer.vue.d.ts

@@ -0,0 +1,15 @@
+import type { NStepperContainerProps } from '../../types/index.js';
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<NStepperContainerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<NStepperContainerProps> & Readonly<{}>, {
+    orientation: "vertical" | "horizontal";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};