@strux-sh/ui 0.0.1

package/dist/components/Button/Button.variants.d.ts

@@ -0,0 +1,17 @@
+import { type VariantProps } from "class-variance-authority";
+/**
+ * Button class variance configuration.
+ *
+ * The variant set is designed around how the strux-website actually
+ * styles its buttons, not lifted wholesale from shadcn. The Strux
+ * primary is the indigo-500 fill with indigo-400 hover; outline is
+ * the slate-700/80 border with indigo hover; secondary is a filled
+ * neutral surface for medium-emphasis actions; ghost is bare-bones;
+ * destructive uses the danger token; link reads as inline text.
+ */
+export declare const buttonVariants: (props?: ({
+    variant?: "link" | "warn" | "secondary" | "outline" | "destructive" | "primary" | "ghost" | "success" | null | undefined;
+    size?: "sm" | "md" | "lg" | "icon" | null | undefined;
+    block?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type ButtonVariants = VariantProps<typeof buttonVariants>;

package/dist/components/Button/Button.vue.d.ts

@@ -0,0 +1,35 @@
+import { type HTMLAttributes } from "vue";
+import { type ButtonVariants } from "./Button.variants";
+interface Props {
+    variant?: ButtonVariants["variant"];
+    size?: ButtonVariants["size"];
+    block?: boolean;
+    loading?: boolean;
+    disabled?: boolean;
+    type?: "button" | "submit" | "reset";
+    href?: string;
+    class?: HTMLAttributes["class"];
+}
+type __VLS_Slots = {
+    default(): unknown;
+    leading(): unknown;
+    trailing(): unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {
+    size: "sm" | "md" | "lg" | "icon" | null;
+    class: string | false | Record<string, any> | import("vue").ClassValue[] | null;
+    type: "button" | "submit" | "reset";
+    disabled: boolean;
+    href: string;
+    variant: "link" | "warn" | "secondary" | "outline" | "destructive" | "primary" | "ghost" | "success" | null;
+    block: boolean;
+    loading: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,2 @@
+export { default as Button } from "./Button.vue";
+export { buttonVariants, type ButtonVariants } from "./Button.variants";

package/dist/components/Calendar/Calendar.variants.d.ts

@@ -0,0 +1,5 @@
+import { type VariantProps } from "class-variance-authority";
+export declare const calendarVariants: (props?: ({
+    size?: "sm" | "md" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type CalendarVariants = VariantProps<typeof calendarVariants>;

package/dist/components/Calendar/Calendar.vue.d.ts

@@ -0,0 +1,74 @@
+import { type CSSProperties, type HTMLAttributes } from "vue";
+import type { CalendarEvent, CalendarView, CalendarNavigation } from "./types";
+interface Props {
+    events?: CalendarEvent[];
+    view?: CalendarView;
+    date?: Date;
+    slotDuration?: number;
+    slotHeight?: number;
+    startHour?: number;
+    endHour?: number;
+    weekStartsOn?: 0 | 1;
+    readonly?: boolean;
+    size?: "sm" | "md";
+    class?: HTMLAttributes["class"];
+}
+type __VLS_Slots = {
+    header(props: {
+        view: CalendarView;
+        date: Date;
+        nav: CalendarNavigation;
+    }): unknown;
+    "day-header"(props: {
+        date: Date;
+        isToday: boolean;
+    }): unknown;
+    event(props: {
+        event: CalendarEvent;
+        style: CSSProperties;
+    }): unknown;
+    "event-content"(props: {
+        event: CalendarEvent;
+    }): unknown;
+    "month-cell"(props: {
+        date: Date;
+        events: CalendarEvent[];
+    }): unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:view": (view: CalendarView) => any;
+    "day-click": (date: Date) => any;
+    "slot-click": (date: Date) => any;
+    "event-click": (event: CalendarEvent) => any;
+    "update:date": (date: Date) => any;
+    "event-move": (id: string, newStart: Date, newEnd: Date) => any;
+    "event-resize": (id: string, newStart: Date, newEnd: Date) => any;
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:view"?: ((view: CalendarView) => any) | undefined;
+    "onDay-click"?: ((date: Date) => any) | undefined;
+    "onSlot-click"?: ((date: Date) => any) | undefined;
+    "onEvent-click"?: ((event: CalendarEvent) => any) | undefined;
+    "onUpdate:date"?: ((date: Date) => any) | undefined;
+    "onEvent-move"?: ((id: string, newStart: Date, newEnd: Date) => any) | undefined;
+    "onEvent-resize"?: ((id: string, newStart: Date, newEnd: Date) => any) | undefined;
+}>, {
+    size: "sm" | "md";
+    class: string | false | Record<string, any> | import("vue").ClassValue[] | null;
+    view: CalendarView;
+    date: Date;
+    slotDuration: number;
+    slotHeight: number;
+    startHour: number;
+    endHour: number;
+    readonly: boolean;
+    events: CalendarEvent[];
+    weekStartsOn: 0 | 1;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Calendar/CalendarDayColumn.vue.d.ts

@@ -0,0 +1,40 @@
+import { type CSSProperties } from "vue";
+import type { CalendarEvent } from "./types";
+interface Props {
+    day: Date;
+    events: CalendarEvent[];
+    slotDuration: number;
+    slotHeight: number;
+    startHour?: number;
+    endHour?: number;
+    selectedEventId: string | null;
+    readonly?: boolean;
+}
+type __VLS_Slots = {
+    event(props: {
+        event: CalendarEvent;
+        style: CSSProperties;
+    }): unknown;
+    "event-content"(props: {
+        event: CalendarEvent;
+    }): unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "slot-click": (date: Date) => any;
+    "event-click": (event: CalendarEvent) => any;
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+    "onSlot-click"?: ((date: Date) => any) | undefined;
+    "onEvent-click"?: ((event: CalendarEvent) => any) | undefined;
+}>, {
+    startHour: number;
+    endHour: number;
+    readonly: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Calendar/CalendarDayHeader.vue.d.ts

@@ -0,0 +1,10 @@
+interface Props {
+    date: Date;
+}
+declare const __VLS_export: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "day-click": (date: Date) => any;
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+    "onDay-click"?: ((date: Date) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/Calendar/CalendarDayView.vue.d.ts

@@ -0,0 +1,42 @@
+import { type CSSProperties } from "vue";
+import type { CalendarEvent } from "./types";
+interface Props {
+    date: Date;
+    events: CalendarEvent[];
+    slotDuration: number;
+    slotHeight: number;
+    startHour?: number;
+    endHour?: number;
+    selectedEventId: string | null;
+    timeSelected?: Date | null;
+    readonly?: boolean;
+}
+type __VLS_Slots = {
+    event(props: {
+        event: CalendarEvent;
+        style: CSSProperties;
+    }): unknown;
+    "event-content"(props: {
+        event: CalendarEvent;
+    }): unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "slot-click": (date: Date) => any;
+    "event-click": (event: CalendarEvent) => any;
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+    "onSlot-click"?: ((date: Date) => any) | undefined;
+    "onEvent-click"?: ((event: CalendarEvent) => any) | undefined;
+}>, {
+    startHour: number;
+    endHour: number;
+    timeSelected: Date | null;
+    readonly: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Calendar/CalendarEvent.variants.d.ts

@@ -0,0 +1,6 @@
+import { type VariantProps } from "class-variance-authority";
+export declare const calendarEventVariants: (props?: ({
+    color?: "info" | "warn" | "danger" | "ok" | "accent" | null | undefined;
+    selected?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type CalendarEventVariants = VariantProps<typeof calendarEventVariants>;

package/dist/components/Calendar/CalendarEvent.vue.d.ts

@@ -0,0 +1,39 @@
+import { type CSSProperties, type HTMLAttributes } from "vue";
+import type { CalendarEvent } from "./types";
+interface Props {
+    event: CalendarEvent;
+    style: CSSProperties;
+    selected?: boolean;
+    readonly?: boolean;
+    slotDuration?: number;
+    slotHeight?: number;
+    class?: HTMLAttributes["class"];
+}
+type __VLS_Slots = {
+    event(props: {
+        event: CalendarEvent;
+        style: CSSProperties;
+    }): unknown;
+    "event-content"(props: {
+        event: CalendarEvent;
+    }): unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "event-click": (event: CalendarEvent) => any;
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+    "onEvent-click"?: ((event: CalendarEvent) => any) | undefined;
+}>, {
+    class: string | false | Record<string, any> | import("vue").ClassValue[] | null;
+    slotDuration: number;
+    slotHeight: number;
+    selected: boolean;
+    readonly: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Calendar/CalendarEventGroup.vue.d.ts

@@ -0,0 +1,36 @@
+import type { CSSProperties } from "vue";
+import type { CalendarEvent as CalendarEventType, EventGroup } from "./types";
+interface Props {
+    group: EventGroup;
+    layout: {
+        eventStyle: (event: CalendarEventType, groupSize: number, index: number) => CSSProperties;
+    };
+    selectedEventId: string | null;
+    slotDuration: number;
+    slotHeight: number;
+    readonly?: boolean;
+}
+type __VLS_Slots = {
+    event(props: {
+        event: CalendarEventType;
+        style: CSSProperties;
+    }): unknown;
+    "event-content"(props: {
+        event: CalendarEventType;
+    }): unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "event-click": (event: CalendarEventType) => any;
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+    "onEvent-click"?: ((event: CalendarEventType) => any) | undefined;
+}>, {
+    readonly: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Calendar/CalendarHeader.variants.d.ts

@@ -0,0 +1,9 @@
+import { type VariantProps } from "class-variance-authority";
+export declare const calendarHeaderVariants: (props?: ({
+    size?: "sm" | "md" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export declare const viewToggleVariants: (props?: ({
+    active?: boolean | null | undefined;
+    size?: "sm" | "md" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type CalendarHeaderVariants = VariantProps<typeof calendarHeaderVariants>;

package/dist/components/Calendar/CalendarHeader.vue.d.ts

@@ -0,0 +1,23 @@
+import type { CalendarView } from "./types";
+interface Props {
+    title: string;
+    view: CalendarView;
+    size?: "sm" | "md";
+    class?: string;
+}
+declare const __VLS_export: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    next: () => any;
+    prev: () => any;
+    today: () => any;
+    "update:view": (view: CalendarView) => any;
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+    onNext?: (() => any) | undefined;
+    onPrev?: (() => any) | undefined;
+    onToday?: (() => any) | undefined;
+    "onUpdate:view"?: ((view: CalendarView) => any) | undefined;
+}>, {
+    size: "sm" | "md";
+    class: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/Calendar/CalendarMonthCell.vue.d.ts

@@ -0,0 +1,30 @@
+import type { CalendarEvent } from "./types";
+interface Props {
+    date: Date;
+    events: CalendarEvent[];
+    referenceDate: Date;
+    maxVisible?: number;
+}
+type __VLS_Slots = {
+    "month-cell"(props: {
+        date: Date;
+        events: CalendarEvent[];
+    }): unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "day-click": (date: Date) => any;
+    "event-click": (event: CalendarEvent) => any;
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+    "onDay-click"?: ((date: Date) => any) | undefined;
+    "onEvent-click"?: ((event: CalendarEvent) => any) | undefined;
+}>, {
+    maxVisible: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Calendar/CalendarMonthEvent.vue.d.ts

@@ -0,0 +1,11 @@
+import type { CalendarEvent } from "./types";
+interface Props {
+    event: CalendarEvent;
+}
+declare const __VLS_export: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "event-click": (event: CalendarEvent) => any;
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+    "onEvent-click"?: ((event: CalendarEvent) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/Calendar/CalendarMonthView.vue.d.ts

@@ -0,0 +1,30 @@
+import type { CalendarEvent } from "./types";
+interface Props {
+    dates: Date[];
+    events: CalendarEvent[];
+    referenceDate: Date;
+    weekStartsOn?: 0 | 1;
+}
+type __VLS_Slots = {
+    "month-cell"(props: {
+        date: Date;
+        events: CalendarEvent[];
+    }): unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "day-click": (date: Date) => any;
+    "event-click": (event: CalendarEvent) => any;
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+    "onDay-click"?: ((date: Date) => any) | undefined;
+    "onEvent-click"?: ((event: CalendarEvent) => any) | undefined;
+}>, {
+    weekStartsOn: 0 | 1;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Calendar/CalendarSlotGrid.vue.d.ts

@@ -0,0 +1,17 @@
+interface Props {
+    day: Date;
+    slotDuration: number;
+    slotHeight: number;
+    startHour?: number;
+    endHour?: number;
+}
+declare const __VLS_export: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "slot-click": (date: Date) => any;
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+    "onSlot-click"?: ((date: Date) => any) | undefined;
+}>, {
+    startHour: number;
+    endHour: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/Calendar/CalendarTimeAxis.vue.d.ts

@@ -0,0 +1,14 @@
+interface Props {
+    slotDuration: number;
+    slotHeight: number;
+    startHour?: number;
+    endHour?: number;
+    timeSelected?: Date | null;
+}
+declare const __VLS_export: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {
+    startHour: number;
+    endHour: number;
+    timeSelected: Date | null;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/Calendar/CalendarWeekView.vue.d.ts

@@ -0,0 +1,48 @@
+import { type CSSProperties } from "vue";
+import type { CalendarEvent } from "./types";
+interface Props {
+    dates: Date[];
+    events: CalendarEvent[];
+    slotDuration: number;
+    slotHeight: number;
+    startHour?: number;
+    endHour?: number;
+    selectedEventId: string | null;
+    timeSelected?: Date | null;
+    readonly?: boolean;
+}
+type __VLS_Slots = {
+    "day-header"(props: {
+        date: Date;
+        isToday: boolean;
+    }): unknown;
+    event(props: {
+        event: CalendarEvent;
+        style: CSSProperties;
+    }): unknown;
+    "event-content"(props: {
+        event: CalendarEvent;
+    }): unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "day-click": (date: Date) => any;
+    "slot-click": (date: Date) => any;
+    "event-click": (event: CalendarEvent) => any;
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+    "onDay-click"?: ((date: Date) => any) | undefined;
+    "onSlot-click"?: ((date: Date) => any) | undefined;
+    "onEvent-click"?: ((event: CalendarEvent) => any) | undefined;
+}>, {
+    startHour: number;
+    endHour: number;
+    timeSelected: Date | null;
+    readonly: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Calendar/composables/useCalendarDrag.d.ts

@@ -0,0 +1,12 @@
+import { type Ref } from "vue";
+import type { Timeslot } from "../types";
+export interface UseCalendarDragOptions {
+    slotDuration: number;
+    onMove?: (eventId: string, newStart: Date, newEnd: Date) => void;
+}
+export declare function useCalendarDrag(options: UseCalendarDragOptions): {
+    isDragging: Ref<boolean, boolean>;
+    draggingEventId: Ref<string | null, string | null>;
+    currentDropSlot: Ref<Timeslot | null, Timeslot | null>;
+    startDrag: (e: PointerEvent, eventId: string, originalStart: Date, originalEnd: Date) => void;
+};

package/dist/components/Calendar/composables/useCalendarLayout.d.ts

@@ -0,0 +1,13 @@
+import type { CSSProperties } from "vue";
+import type { CalendarEvent, EventGroup } from "../types";
+export interface UseCalendarLayoutOptions {
+    slotDuration: number;
+    slotHeight: number;
+    startHour: number;
+    endHour: number;
+}
+export declare function useCalendarLayout(options: UseCalendarLayoutOptions): {
+    eventStyle: (event: CalendarEvent, groupSize: number, indexInGroup: number) => CSSProperties;
+    groupStyle: (group: EventGroup) => CSSProperties;
+    gridHeight: () => string;
+};

package/dist/components/Calendar/composables/useCalendarNavigation.d.ts

@@ -0,0 +1,18 @@
+import { type Ref } from "vue";
+import type { CalendarView } from "../types";
+export interface UseCalendarNavigationOptions {
+    initialDate?: Date;
+    initialView?: CalendarView;
+    weekStartsOn?: 0 | 1;
+}
+export declare function useCalendarNavigation(options?: UseCalendarNavigationOptions): {
+    currentDate: Ref<Date, Date>;
+    currentView: Ref<CalendarView, CalendarView>;
+    title: import("vue").ComputedRef<string>;
+    visibleDates: import("vue").ComputedRef<Date[]>;
+    next: () => void;
+    prev: () => void;
+    today: () => void;
+    goToDate: (date: Date) => void;
+    setView: (view: CalendarView) => void;
+};

package/dist/components/Calendar/composables/useCalendarResize.d.ts

@@ -0,0 +1,14 @@
+import { type Ref } from "vue";
+export type ResizeEdge = "top" | "bottom";
+export interface UseCalendarResizeOptions {
+    slotDuration: number;
+    slotHeight: number;
+    startHour: number;
+    onResize?: (eventId: string, newStart: Date, newEnd: Date) => void;
+}
+export declare function useCalendarResize(options: UseCalendarResizeOptions): {
+    isResizing: Ref<boolean, boolean>;
+    resizingEventId: Ref<string | null, string | null>;
+    resizingEdge: Ref<ResizeEdge | null, ResizeEdge | null>;
+    startResize: (e: PointerEvent, eventId: string, edge: ResizeEdge, originalStart: Date, originalEnd: Date) => void;
+};

package/dist/components/Calendar/composables/useCalendarSelection.d.ts

@@ -0,0 +1,7 @@
+export declare function useCalendarSelection(): {
+    selectedEventId: import("vue").Ref<string | null, string | null>;
+    select: (id: string) => void;
+    deselect: () => void;
+    toggle: (id: string) => void;
+    isSelected: (id: string) => import("vue").ComputedRef<boolean>;
+};

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

@@ -0,0 +1,5 @@
+export { default as Calendar } from "./Calendar.vue";
+export { calendarVariants, type CalendarVariants } from "./Calendar.variants";
+export { calendarEventVariants, type CalendarEventVariants } from "./CalendarEvent.variants";
+export { calendarHeaderVariants, type CalendarHeaderVariants } from "./CalendarHeader.variants";
+export type { CalendarEvent, CalendarView, CalendarEventColor, CalendarNavigation } from "./types";

package/dist/components/Calendar/types.d.ts

@@ -0,0 +1,38 @@
+import type { InjectionKey } from "vue";
+export type CalendarView = "week" | "day" | "month";
+export type CalendarEventColor = "accent" | "info" | "warn" | "danger" | "ok";
+export interface CalendarEvent {
+    id: string;
+    title?: string;
+    start: Date;
+    end: Date;
+    color?: CalendarEventColor;
+    data?: Record<string, unknown>;
+}
+export interface Timeslot {
+    id: string;
+    start: Date;
+    end: Date;
+}
+/** Internal: group of overlapping events rendered side-by-side */
+export type EventGroup = CalendarEvent[];
+/** Navigation actions exposed to the #header slot */
+export interface CalendarNavigation {
+    next: () => void;
+    prev: () => void;
+    today: () => void;
+    setView: (view: CalendarView) => void;
+    goToDate: (date: Date) => void;
+}
+/** Provided by Calendar.vue, injected by CalendarEvent.vue for real-time drag/resize */
+export interface CalendarDragHandler {
+    onDragStart: (eventId: string) => void;
+    onDragOver: (eventId: string, slotStart: Date) => void;
+    onDragEnd: (eventId: string) => void;
+    onResizeStart: (eventId: string, edge: "top" | "bottom") => void;
+    onResizeOver: (eventId: string, slotStart: Date, slotEnd: Date) => void;
+    onResizeEnd: (eventId: string) => void;
+    dragEventId: string | null;
+    resizeEventId: string | null;
+}
+export declare const CALENDAR_DRAG_KEY: InjectionKey<CalendarDragHandler>;

package/dist/components/Calendar/utils/overlap.d.ts

@@ -0,0 +1,12 @@
+import type { CalendarEvent, EventGroup } from "../types";
+export declare function sortEventsByTime(events: CalendarEvent[]): CalendarEvent[];
+/**
+ * Groups overlapping events for side-by-side rendering.
+ * Events within the same group overlap with at least one other
+ * member and are rendered with divided widths.
+ */
+export declare function groupOverlappingEvents(events: CalendarEvent[]): EventGroup[];
+export declare function getGroupSpan(group: EventGroup): {
+    start: Date;
+    end: Date;
+};

package/dist/components/Calendar/utils/positioning.d.ts

@@ -0,0 +1,3 @@
+export declare function timeToRem(date: Date, slotDuration: number, slotHeight: number, startHour?: number): number;
+export declare function durationToRem(start: Date, end: Date, slotDuration: number, slotHeight: number): number;
+export declare function totalGridHeight(slotDuration: number, slotHeight: number, startHour?: number, endHour?: number): number;

package/dist/components/Calendar/utils/slots.d.ts

@@ -0,0 +1,2 @@
+import type { Timeslot } from "../types";
+export declare function generateSlots(slotDuration: number, day: Date, startHour?: number, endHour?: number): Timeslot[];