@wow-two-beta/ui-vue 0.0.2

package/dist/presentation/forms/timeField/index.d.ts

@@ -0,0 +1 @@
+export { default as TimeField, type TimeFieldProps } from './TimeField.vue';

package/dist/presentation/forms/timePicker/TimePicker.vue.d.ts

@@ -0,0 +1,50 @@
+import { Temporal as TemporalValue, Temporal } from 'temporal-polyfill';
+import { SelectSize } from '../select';
+import { InputState } from '../InputStyles';
+import { DefineComponent, ComputedRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface TimePickerProps {
+    /** The selected time, controlled — React's spelling, which wins when both are set. */
+    value?: Temporal.PlainTime | null;
+    /** The selected time, controlled. The `v-model` binding target. */
+    modelValue?: Temporal.PlainTime | null;
+    /** The uncontrolled initial selection. */
+    defaultValue?: Temporal.PlainTime | null;
+    /** The minute interval. Default 5. */
+    minuteStep?: number;
+    /** The empty-state text on the trigger. */
+    placeholder?: string;
+    /**
+     * The trigger's time formatter.
+     *
+     * Kept a PROP, not an emit: it RETURNS the rendered string, which an emit cannot do.
+     */
+    format?: (time: Temporal.PlainTime) => string;
+    /** The invalid surface override. Falls back to the surrounding form control's `isInvalid`. */
+    isInvalid?: boolean;
+    /** The hidden input name; when set, a hidden input ships the value with form submission. */
+    name?: string;
+    /** The trigger size. */
+    size?: SelectSize;
+    /** The validity surface. */
+    state?: InputState;
+    /** The trigger's id. Auto-filled from `FormControl` context when omitted. */
+    id?: string;
+    /** The disabled state. Falls back to the surrounding form control's `isDisabled`. */
+    disabled?: boolean;
+}
+declare const _default: DefineComponent<TimePickerProps, {
+    el: ComputedRef<HTMLElement | null>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "value-change": (time: TemporalValue.PlainTime | null) => any;
+    "update:modelValue": (time: TemporalValue.PlainTime | null) => any;
+}, string, PublicProps, Readonly<TimePickerProps> & Readonly<{
+    "onValue-change"?: ((time: TemporalValue.PlainTime | null) => any) | undefined;
+    "onUpdate:modelValue"?: ((time: TemporalValue.PlainTime | null) => any) | undefined;
+}>, {
+    disabled: boolean;
+    format: (time: Temporal.PlainTime) => string;
+    placeholder: string;
+    isInvalid: boolean;
+    minuteStep: number;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/presentation/forms/timePicker/index.d.ts

@@ -0,0 +1 @@
+export { default as TimePicker, type TimePickerProps } from './TimePicker.vue';

package/dist/presentation/forms/urlInput/UrlInput.vue.d.ts

@@ -0,0 +1,43 @@
+import { InputSize, InputState, InputBorder, InputRing } from '../InputStyles';
+import { DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface UrlInputProps {
+    /** The control size. */
+    size?: InputSize;
+    /** The validity surface. */
+    state?: InputState;
+    /** The border weight. */
+    border?: InputBorder;
+    /** The focus-ring weight. */
+    ring?: InputRing;
+    /** The value, controlled. The `v-model` binding target. */
+    modelValue?: string | number;
+    /** The value, controlled — React's spelling of `modelValue`, which wins when both are set. */
+    value?: string | number;
+    /** The initial value when uncontrolled. */
+    defaultValue?: string | number;
+    /** The control's id. Auto-filled from `FormControl` context when omitted. */
+    id?: string;
+    /** The disabled state. Falls back to the surrounding form control's `isDisabled`. */
+    disabled?: boolean;
+    /** The required state. Falls back to the surrounding form control's `isRequired`. */
+    required?: boolean;
+    /** The read-only state — React's spelling. Falls back to the form control's `isReadOnly`. */
+    readOnly?: boolean;
+    /** The DOM spelling of {@link UrlInputProps.readOnly}, which wins when both are set. */
+    readonly?: boolean;
+}
+declare const _default: DefineComponent<UrlInputProps, {
+    el: Readonly< ShallowRef<HTMLInputElement | null>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "value-change": (value: string) => any;
+    "update:modelValue": (value: string) => any;
+}, string, PublicProps, Readonly<UrlInputProps> & Readonly<{
+    "onValue-change"?: ((value: string) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    disabled: boolean;
+    required: boolean;
+    readOnly: boolean;
+    readonly: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/presentation/forms/urlInput/index.d.ts

@@ -0,0 +1 @@
+export { default as UrlInput, type UrlInputProps } from './UrlInput.vue';

package/dist/presentation/forms/wizard/Wizard.vue.d.ts

@@ -0,0 +1,38 @@
+import { DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface WizardProps {
+    /** The active step id, controlled. The `v-model:current-step` binding target. */
+    currentStep?: string;
+    /** The initial active step id when uncontrolled. Defaults to the first registered step. */
+    defaultCurrentStep?: string;
+    /**
+     * The completion handler, awaited on the final step's Next.
+     *
+     * Kept a PROP, not an emit: the root AWAITS its result to hold `isPending`, and an emit
+     * returns nothing to await.
+     */
+    onComplete?: () => void | Promise<void>;
+    /** Whether the Back control and step back-jumps are available. Default `true`. */
+    canGoBack?: boolean;
+}
+declare const _default: __VLS_WithSlots< DefineComponent<WizardProps, {
+    el: Readonly< ShallowRef<HTMLDivElement | null>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "step-change": (step: string) => any;
+    "update:currentStep": (step: string) => any;
+}, string, PublicProps, Readonly<WizardProps> & Readonly<{
+    "onStep-change"?: ((step: string) => any) | undefined;
+    "onUpdate:currentStep"?: ((step: string) => any) | undefined;
+}>, {
+    currentStep: string;
+    defaultCurrentStep: string;
+    onComplete: () => void | Promise<void>;
+    canGoBack: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
+    default(): unknown;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/presentation/forms/wizard/WizardContext.d.ts

@@ -0,0 +1,38 @@
+import { InjectionKey } from 'vue';
+/** Describes one registered wizard step. */
+export interface StepInfo {
+    id: string;
+    /** React typed this `ReactNode`; it is scalar here because `WizardSteps` renders it as
+     *  the tab's text. A rich step tab is not part of the original's contract either. */
+    label?: string | number;
+    isOptional?: boolean;
+    isFinal?: boolean;
+}
+/**
+ * The seam between `Wizard` and its `Steps` / `Step` / `Footer` children.
+ *
+ * React attached those as `Wizard.Steps` / `.Step` / `.Footer` statics over a `createContext`,
+ * and pre-walked `Children.toArray` to discover step ids before mount. An SFC's default export
+ * cannot carry statics and Vue has no children-walk, so the parts ship as siblings and register
+ * themselves through provide/inject — the same conversion `checkboxGroup` / `radioGroup` made.
+ *
+ * Every field but the functions is a live getter — read them off the object, don't destructure.
+ */
+export interface WizardContextValue {
+    readonly steps: ReadonlyArray<StepInfo>;
+    readonly currentIndex: number;
+    readonly currentStep: StepInfo | undefined;
+    goTo: (idOrIndex: string | number) => void;
+    next: () => Promise<void>;
+    back: () => void;
+    readonly canGoBack: boolean;
+    readonly visited: ReadonlySet<string>;
+    registerStep: (info: StepInfo) => void;
+    unregisterStep: (id: string) => void;
+    registerValidator: (id: string, validator: () => boolean | Promise<boolean>) => void;
+    unregisterValidator: (id: string) => void;
+    readonly isPending: boolean;
+}
+export declare const wizardContextKey: InjectionKey<WizardContextValue>;
+/** Reads the surrounding wizard context; throws when used outside a `<Wizard>`. */
+export declare function useWizard(): WizardContextValue;

package/dist/presentation/forms/wizard/WizardFooter.vue.d.ts

@@ -0,0 +1,29 @@
+import { DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface WizardFooterProps {
+    /** The Back button's text. Fill the `prevLabel` slot for richer content. */
+    prevLabel?: string | number;
+    /** The Next button's text. Fill the `nextLabel` slot for richer content. */
+    nextLabel?: string | number;
+    /** The final step's confirm text. Fill the `submitLabel` slot for richer content. */
+    submitLabel?: string | number;
+    /** The visibility of the Prev button when not on first step. Default true. */
+    hasPrev?: boolean;
+}
+declare const _default: __VLS_WithSlots< DefineComponent<WizardFooterProps, {
+    el: Readonly< ShallowRef<HTMLDivElement | null>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<WizardFooterProps> & Readonly<{}>, {
+    prevLabel: string | number;
+    nextLabel: string | number;
+    submitLabel: string | number;
+    hasPrev: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
+    prevLabel?(): unknown;
+    nextLabel?(): unknown;
+    submitLabel?(): unknown;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/presentation/forms/wizard/WizardStep.vue.d.ts

@@ -0,0 +1,29 @@
+import { DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface WizardStepProps {
+    /** The step id — the value `currentStep` takes when this step is active. */
+    id: string;
+    /** The step-strip label. Defaults to the id. */
+    label?: string | number;
+    /**
+     * The gate run before advancing off this step. Resolving `false` blocks the move.
+     *
+     * Kept a PROP, not an emit: it RETURNS a verdict (possibly a promise), which an emit
+     * cannot do.
+     */
+    validate?: () => boolean | Promise<boolean>;
+    /** Whether the step strip marks this step `(optional)`. */
+    isOptional?: boolean;
+    /** Whether this is the last step — Next becomes the submit action. */
+    isFinal?: boolean;
+}
+declare const _default: __VLS_WithSlots< DefineComponent<WizardStepProps, {
+    el: Readonly< ShallowRef<HTMLDivElement | null>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<WizardStepProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
+    default(): unknown;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/presentation/forms/wizard/WizardSteps.vue.d.ts

@@ -0,0 +1,7 @@
+import { DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface WizardStepsProps {
+}
+declare const _default: DefineComponent<{}, {
+    el: Readonly< ShallowRef<HTMLDivElement | null>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/presentation/forms/wizard/index.d.ts

@@ -0,0 +1,6 @@
+export { default as Wizard, type WizardProps } from './Wizard.vue';
+export { default as WizardFooter, type WizardFooterProps } from './WizardFooter.vue';
+export { default as WizardStep, type WizardStepProps } from './WizardStep.vue';
+export { default as WizardSteps, type WizardStepsProps } from './WizardSteps.vue';
+export { useWizard, type StepInfo, type WizardContextValue } from './WizardContext';
+export { default } from './Wizard.vue';

package/dist/presentation/layout/appShell/AppShell.vue.d.ts

@@ -0,0 +1,90 @@
+import { ComputedRef, InjectionKey, Ref, DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+/** Defines the responsive breakpoint at which `AppShell` collapses its sidebar / aside. */
+export declare const Breakpoint: {
+    /** Refers to the `sm` (640px) breakpoint. */
+    readonly Sm: "sm";
+    /** Refers to the `md` (768px) breakpoint. */
+    readonly Md: "md";
+    /** Refers to the `lg` (1024px) breakpoint. */
+    readonly Lg: "lg";
+    /** Refers to the `xl` (1280px) breakpoint. */
+    readonly Xl: "xl";
+    /** Refers to the `2xl` (1536px) breakpoint. */
+    readonly Xxl: "2xl";
+};
+export type Breakpoint = (typeof Breakpoint)[keyof typeof Breakpoint];
+/**
+ * The value shared with `AppShellSidebar` / `AppShellAside`.
+ *
+ * React's context held plain values re-created on every render behind a
+ * `useMemo`; here every field stays a ref or a computed, so a child reads the
+ * live value and the root never re-renders to publish one.
+ */
+export interface AppShellContextValue {
+    sidebarWidth: ComputedRef<string>;
+    asideWidth: ComputedRef<string>;
+    sidebarBreakpoint: ComputedRef<Breakpoint>;
+    /** The resolved mobile-sidebar open state. Writable — an assignment routes through `setSidebarOpen`. */
+    isSidebarOpen: Ref<boolean>;
+    setSidebarOpen: (open: boolean) => void;
+    /** True below `sidebarBreakpoint` — the sidebar renders as a `Drawer`. */
+    isSidebarCollapsed: ComputedRef<boolean>;
+    /** True below `asideBreakpoint` — the aside renders nothing. */
+    isAsideHidden: ComputedRef<boolean>;
+}
+export declare const appShellContextKey: InjectionKey<AppShellContextValue>;
+export declare function useAppShellContext(): AppShellContextValue;
+/** Reads the enclosing `AppShell`'s state — widths, breakpoint, and the mobile-sidebar toggle. */
+export declare function useAppShell(): AppShellContextValue;
+/**
+ * The prop surface of `AppShell`.
+ *
+ * `sidebarOpen` and `isSidebarOpen` are the same controlled state under two
+ * names: `sidebarOpen` is the `v-model:sidebarOpen` binding target,
+ * `isSidebarOpen` React's spelling. `isSidebarOpen` wins when both are set —
+ * React's name always resolves first, so an explicit binding is never
+ * swallowed by a `v-model` that is also present.
+ * React's `onSidebarOpenChange` is the `sidebar-open-change` emit;
+ * `update:sidebarOpen` fires alongside it so `v-model` works.
+ */
+export interface AppShellProps {
+    /** The sidebar column width, any CSS length. Default `240px`. */
+    sidebarWidth?: string;
+    /** The aside rail width, any CSS length. Default `280px`. */
+    asideWidth?: string;
+    /** The sidebar collapses below this breakpoint. Default `lg`. */
+    sidebarBreakpoint?: Breakpoint;
+    /** The aside hides below this breakpoint. Default `xl`. */
+    asideBreakpoint?: Breakpoint;
+    /** The mobile-sidebar open state, controlled. The `v-model:sidebarOpen` binding target. */
+    sidebarOpen?: boolean;
+    /** The mobile-sidebar open state, controlled — React's spelling, which wins when both are set. */
+    isSidebarOpen?: boolean;
+    /** The initial mobile-sidebar state when uncontrolled. Default `false`. */
+    defaultSidebarOpen?: boolean;
+}
+declare const _default: __VLS_WithSlots< DefineComponent<AppShellProps, {
+    el: Readonly< ShallowRef<HTMLDivElement | null>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "update:sidebarOpen": (open: boolean) => any;
+    "sidebar-open-change": (open: boolean) => any;
+}, string, PublicProps, Readonly<AppShellProps> & Readonly<{
+    "onUpdate:sidebarOpen"?: ((open: boolean) => any) | undefined;
+    "onSidebar-open-change"?: ((open: boolean) => any) | undefined;
+}>, {
+    asideWidth: string;
+    sidebarWidth: string;
+    sidebarBreakpoint: Breakpoint;
+    asideBreakpoint: Breakpoint;
+    sidebarOpen: boolean;
+    isSidebarOpen: boolean;
+    defaultSidebarOpen: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
+    default(): unknown;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/presentation/layout/appShell/AppShellAside.vue.d.ts

@@ -0,0 +1,20 @@
+import { DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+/**
+ * The prop surface of `AppShellAside`.
+ *
+ * React declared `HTMLAttributes<HTMLElement>`; attributes reach the root
+ * through `useAttrs` here and `children` is the default slot, which leaves no
+ * declared prop.
+ */
+export type AppShellAsideProps = Record<string, never>;
+declare const _default: __VLS_WithSlots< DefineComponent<{}, {
+    el: Readonly< ShallowRef<HTMLElement | null>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>, {
+    default?(): unknown;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/presentation/layout/appShell/AppShellContent.vue.d.ts

@@ -0,0 +1,20 @@
+import { DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+/**
+ * The prop surface of `AppShellContent`.
+ *
+ * React declared `HTMLAttributes<HTMLDivElement>`; attributes reach the root
+ * through `useAttrs` here and `children` is the default slot, which leaves no
+ * declared prop.
+ */
+export type AppShellContentProps = Record<string, never>;
+declare const _default: __VLS_WithSlots< DefineComponent<{}, {
+    el: Readonly< ShallowRef<HTMLDivElement | null>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>, {
+    default?(): unknown;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/presentation/layout/appShell/AppShellFooter.vue.d.ts

@@ -0,0 +1,20 @@
+import { DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+/**
+ * The prop surface of `AppShellFooter`.
+ *
+ * React declared `HTMLAttributes<HTMLElement>`; attributes reach the root
+ * through `useAttrs` here and `children` is the default slot, which leaves no
+ * declared prop.
+ */
+export type AppShellFooterProps = Record<string, never>;
+declare const _default: __VLS_WithSlots< DefineComponent<{}, {
+    el: Readonly< ShallowRef<HTMLElement | null>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>, {
+    default?(): unknown;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/presentation/layout/appShell/AppShellHeader.vue.d.ts

@@ -0,0 +1,20 @@
+import { DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+/**
+ * The prop surface of `AppShellHeader`.
+ *
+ * React declared `HTMLAttributes<HTMLElement>`; attributes reach the root
+ * through `useAttrs` here and `children` is the default slot, which leaves no
+ * declared prop.
+ */
+export type AppShellHeaderProps = Record<string, never>;
+declare const _default: __VLS_WithSlots< DefineComponent<{}, {
+    el: Readonly< ShallowRef<HTMLElement | null>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>, {
+    default?(): unknown;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/presentation/layout/appShell/AppShellMain.vue.d.ts

@@ -0,0 +1,20 @@
+import { DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+/**
+ * The prop surface of `AppShellMain`.
+ *
+ * React declared `HTMLAttributes<HTMLElement>`; attributes reach the root
+ * through `useAttrs` here and `children` is the default slot, which leaves no
+ * declared prop.
+ */
+export type AppShellMainProps = Record<string, never>;
+declare const _default: __VLS_WithSlots< DefineComponent<{}, {
+    el: Readonly< ShallowRef<HTMLElement | null>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>, {
+    default?(): unknown;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/presentation/layout/appShell/AppShellSidebar.vue.d.ts

@@ -0,0 +1,20 @@
+import { DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+/**
+ * The prop surface of `AppShellSidebar`.
+ *
+ * React declared `HTMLAttributes<HTMLElement>`; attributes reach the `aside`
+ * through `useAttrs` here and `children` is the default slot, which leaves no
+ * declared prop.
+ */
+export type AppShellSidebarProps = Record<string, never>;
+declare const _default: __VLS_WithSlots< DefineComponent<{}, {
+    el: Readonly< ShallowRef<HTMLElement | null>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>, {
+    default?(): unknown;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/presentation/layout/appShell/index.d.ts

@@ -0,0 +1,7 @@
+export { default as AppShell, Breakpoint, useAppShell, type AppShellProps, type AppShellContextValue, } from './AppShell.vue';
+export { default as AppShellHeader, type AppShellHeaderProps } from './AppShellHeader.vue';
+export { default as AppShellSidebar, type AppShellSidebarProps } from './AppShellSidebar.vue';
+export { default as AppShellMain, type AppShellMainProps } from './AppShellMain.vue';
+export { default as AppShellContent, type AppShellContentProps } from './AppShellContent.vue';
+export { default as AppShellAside, type AppShellAsideProps } from './AppShellAside.vue';
+export { default as AppShellFooter, type AppShellFooterProps } from './AppShellFooter.vue';

package/dist/presentation/layout/aspectRatio/AspectRatio.vue.d.ts

@@ -0,0 +1,18 @@
+import { DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface AspectRatioProps {
+    /** The aspect ratio (width/height). Default 1 (square). */
+    ratio?: number;
+}
+declare const _default: __VLS_WithSlots< DefineComponent<AspectRatioProps, {
+    el: Readonly< ShallowRef<HTMLDivElement | null>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<AspectRatioProps> & Readonly<{}>, {
+    ratio: number;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/presentation/layout/aspectRatio/index.d.ts

@@ -0,0 +1 @@
+export { default as AspectRatio, type AspectRatioProps } from './AspectRatio.vue';

package/dist/presentation/layout/box/Box.vue.d.ts

@@ -0,0 +1,19 @@
+import { ElementType } from '../../../foundation/utils';
+import { DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface BoxProps {
+    /** The HTML element to render. Default `div`. */
+    as?: ElementType;
+}
+declare const _default: __VLS_WithSlots< DefineComponent<BoxProps, {
+    el: Readonly< ShallowRef<HTMLElement | null>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<BoxProps> & Readonly<{}>, {
+    as: ElementType;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/presentation/layout/box/index.d.ts

@@ -0,0 +1 @@
+export { default as Box, type BoxProps } from './Box.vue';

package/dist/presentation/layout/center/Center.vue.d.ts

@@ -0,0 +1,13 @@
+import { HTMLAttributes, DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export type CenterProps = HTMLAttributes;
+declare const _default: __VLS_WithSlots< DefineComponent<{}, {
+    el: Readonly< ShallowRef<HTMLDivElement | null>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/presentation/layout/center/index.d.ts

@@ -0,0 +1 @@
+export { default as Center, type CenterProps } from './Center.vue';

package/dist/presentation/layout/cluster/Cluster.vue.d.ts

@@ -0,0 +1,22 @@
+import { Align } from '../../../foundation/utils';
+import { DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface ClusterProps {
+    /** The gap between children. Default `4`. */
+    gap?: '2' | '3' | '4' | '6' | '8';
+    /** The cross-axis justification. Default `center`. */
+    justify?: Align;
+}
+declare const _default: __VLS_WithSlots< DefineComponent<ClusterProps, {
+    el: Readonly< ShallowRef<HTMLDivElement | null>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ClusterProps> & Readonly<{}>, {
+    justify: Align;
+    gap: "2" | "3" | "4" | "6" | "8";
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/presentation/layout/cluster/index.d.ts

@@ -0,0 +1 @@
+export { default as Cluster, type ClusterProps } from './Cluster.vue';