@morscherlab/mint-sdk 1.0.0-alpha.2

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

@@ -0,0 +1,25 @@
+import { GroupItem } from '../types';
+interface Props {
+    groups: GroupItem[];
+    group1: string[];
+    group2: string[];
+    label1?: string;
+    label2?: string;
+    color1?: string;
+    color2?: string;
+    minPerGroup?: number;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:group1": (names: string[]) => any;
+    "update:group2": (names: string[]) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:group1"?: ((names: string[]) => any) | undefined;
+    "onUpdate:group2"?: ((names: string[]) => any) | undefined;
+}>, {
+    label1: string;
+    label2: string;
+    color1: string;
+    color2: string;
+    minPerGroup: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,12 @@
+interface Props {
+    open: boolean;
+    samples: string[];
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: () => any;
+    apply: (mapping: Record<string, string[]>, columns: string[]) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+    onApply?: ((mapping: Record<string, string[]>, columns: string[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,34 @@
+import { ButtonVariant, ButtonSize } from '../types';
+interface Props {
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+    disabled?: boolean;
+    loading?: boolean;
+    label: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLButtonElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {
+    disabled: boolean;
+    size: ButtonSize;
+    variant: ButtonVariant;
+    loading: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLButtonElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,12 @@
+/** Animated SVG spinner with size and color variants, and a visually hidden status label for screen readers. */
+interface Props {
+    size?: 'xs' | 'sm' | 'md' | 'lg';
+    variant?: 'primary' | 'cta' | 'muted';
+    label?: string;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    label: string;
+    size: "xs" | "sm" | "md" | "lg";
+    variant: "primary" | "cta" | "muted";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,27 @@
+import { MoleculeData } from '../types';
+interface Props {
+    modelValue?: MoleculeData;
+    disabled?: boolean;
+    readonly?: boolean;
+    height?: number;
+    showSmiles?: boolean;
+    placeholder?: string;
+    error?: boolean;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    error: (message: string) => any;
+    "update:modelValue": (data: MoleculeData | undefined) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onError?: ((message: string) => any) | undefined;
+    "onUpdate:modelValue"?: ((data: MoleculeData | undefined) => any) | undefined;
+}>, {
+    error: boolean;
+    disabled: boolean;
+    placeholder: string;
+    readonly: boolean;
+    height: number;
+    showSmiles: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    containerRef: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,19 @@
+import { MultiSelectOption, MultiSelectSize } from '../types';
+interface Props {
+    modelValue: (string | number)[];
+    options: MultiSelectOption[];
+    placeholder?: string;
+    disabled?: boolean;
+    maxSelections?: number;
+    size?: MultiSelectSize;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: (string | number)[]) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: (string | number)[]) => any) | undefined;
+}>, {
+    disabled: boolean;
+    size: MultiSelectSize;
+    placeholder: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,22 @@
+interface Props {
+    modelValue?: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    error?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+    placeholder?: string;
+    unit?: string;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: number | undefined) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: number | undefined) => any) | undefined;
+}>, {
+    error: boolean;
+    disabled: boolean;
+    size: "sm" | "md" | "lg";
+    step: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,50 @@
+import { PlateMapEditorState, WellPlateFormat, SampleType } from '../types';
+interface Props {
+    modelValue?: PlateMapEditorState;
+    format?: WellPlateFormat;
+    maxPlates?: number;
+    samples?: SampleType[];
+    showToolbar?: boolean;
+    showSidebar?: boolean;
+    allowAddPlates?: boolean;
+    allowAddSamples?: boolean;
+    size?: 'sm' | 'md' | 'lg' | 'xl' | 'fill';
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (state: PlateMapEditorState) => any;
+    "plate-add": (plate: {
+        id: string;
+        name: string;
+    }) => any;
+    "plate-remove": (plateId: string) => any;
+    "sample-assign": (wellIds: string[], sampleId: string | undefined) => any;
+    "wells-clear": (wellIds: string[]) => any;
+    undo: () => any;
+    redo: () => any;
+    export: (data: string, format: "csv" | "json") => any;
+    import: (success: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((state: PlateMapEditorState) => any) | undefined;
+    "onPlate-add"?: ((plate: {
+        id: string;
+        name: string;
+    }) => any) | undefined;
+    "onPlate-remove"?: ((plateId: string) => any) | undefined;
+    "onSample-assign"?: ((wellIds: string[], sampleId: string | undefined) => any) | undefined;
+    "onWells-clear"?: ((wellIds: string[]) => any) | undefined;
+    onUndo?: (() => any) | undefined;
+    onRedo?: (() => any) | undefined;
+    onExport?: ((data: string, format: "csv" | "json") => any) | undefined;
+    onImport?: ((success: boolean) => any) | undefined;
+}>, {
+    size: "sm" | "md" | "lg" | "xl" | "fill";
+    modelValue: PlateMapEditorState;
+    format: WellPlateFormat;
+    samples: SampleType[];
+    maxPlates: number;
+    showToolbar: boolean;
+    showSidebar: boolean;
+    allowAddPlates: boolean;
+    allowAddSamples: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,23 @@
+interface Props {
+    value?: number;
+    variant?: 'rail' | 'segmented';
+    color?: 'primary' | 'success' | 'warning' | 'error' | 'info';
+    size?: 'sm' | 'md' | 'lg';
+    label?: string;
+    showValue?: boolean;
+    indeterminate?: boolean;
+    steps?: string[];
+    currentStep?: number;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    label: string;
+    size: "sm" | "md" | "lg";
+    variant: "rail" | "segmented";
+    color: "primary" | "success" | "warning" | "error" | "info";
+    value: number;
+    showValue: boolean;
+    indeterminate: boolean;
+    steps: string[];
+    currentStep: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,24 @@
+import { ProtocolStep } from '../types';
+import { StepTemplate } from '../composables/useProtocolTemplates';
+interface Props {
+    modelValue?: ProtocolStep;
+    templates?: StepTemplate[];
+    customTemplates?: StepTemplate[];
+    mode?: 'create' | 'edit';
+    showPreview?: boolean;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (step: ProtocolStep) => any;
+    cancel: () => any;
+    save: (step: ProtocolStep) => any;
+    "save-template": (template: StepTemplate) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((step: ProtocolStep) => any) | undefined;
+    onCancel?: (() => any) | undefined;
+    onSave?: ((step: ProtocolStep) => any) | undefined;
+    "onSave-template"?: ((template: StepTemplate) => any) | undefined;
+}>, {
+    mode: "create" | "edit";
+    showPreview: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,40 @@
+import { Rack, WellPlateSize, WellEditData } from '../types';
+interface Props {
+    modelValue?: Rack[];
+    activeRackId?: string;
+    maxRacks?: number;
+    minRacks?: number;
+    allowReorder?: boolean;
+    editable?: boolean;
+    readonly?: boolean;
+    wellPlateSize?: WellPlateSize;
+    showLegend?: boolean;
+    showBadges?: boolean;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (racks: Rack[]) => any;
+    "well-edit": (rackId: string, wellId: string, data: WellEditData) => any;
+    "update:activeRackId": (rackId: string) => any;
+    "rack-add": (rack: Rack) => any;
+    "rack-remove": (rackId: string) => any;
+    "rack-reorder": (rackIds: string[]) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((racks: Rack[]) => any) | undefined;
+    "onWell-edit"?: ((rackId: string, wellId: string, data: WellEditData) => any) | undefined;
+    "onUpdate:activeRackId"?: ((rackId: string) => any) | undefined;
+    "onRack-add"?: ((rack: Rack) => any) | undefined;
+    "onRack-remove"?: ((rackId: string) => any) | undefined;
+    "onRack-reorder"?: ((rackIds: string[]) => any) | undefined;
+}>, {
+    modelValue: Rack[];
+    readonly: boolean;
+    showBadges: boolean;
+    editable: boolean;
+    showLegend: boolean;
+    activeRackId: string;
+    maxRacks: number;
+    minRacks: number;
+    allowReorder: boolean;
+    wellPlateSize: WellPlateSize;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,30 @@
+import { LevelEntry, DilutionPreset } from '../composables/useReagentSeries';
+export interface ReagentDefinition {
+    id: string;
+    name: string;
+    color: string;
+    axis: 'row' | 'column';
+    startPosition: string;
+    levels: LevelEntry[];
+    unit: string;
+}
+interface Props {
+    modelValue: ReagentDefinition;
+    plateFormat?: 96 | 384;
+    units?: string[];
+    presets?: DilutionPreset[];
+    maxLevels?: number;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: ReagentDefinition) => any;
+    remove: () => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: ReagentDefinition) => any) | undefined;
+    onRemove?: (() => any) | undefined;
+}>, {
+    plateFormat: 96 | 384;
+    units: string[];
+    presets: DilutionPreset[];
+    maxLevels: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,32 @@
+import { ReagentColumn, Reagent } from '../types';
+interface Props {
+    modelValue?: Reagent[];
+    readonly?: boolean;
+    showStockLevel?: boolean;
+    lowStockThreshold?: number;
+    columns?: ReagentColumn[];
+    sortable?: boolean;
+    searchable?: boolean;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    add: () => any;
+    "update:modelValue": (reagents: Reagent[]) => any;
+    remove: (reagentId: string) => any;
+    edit: (reagent: Reagent) => any;
+    reorder: (reagentId: string, fromIndex: number, toIndex: number) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onAdd?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((reagents: Reagent[]) => any) | undefined;
+    onRemove?: ((reagentId: string) => any) | undefined;
+    onEdit?: ((reagent: Reagent) => any) | undefined;
+    onReorder?: ((reagentId: string, fromIndex: number, toIndex: number) => any) | undefined;
+}>, {
+    modelValue: Reagent[];
+    readonly: boolean;
+    columns: ReagentColumn[];
+    sortable: boolean;
+    searchable: boolean;
+    showStockLevel: boolean;
+    lowStockThreshold: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,50 @@
+import { ResourceStatus, ResourceSpec } from '../types/components';
+interface Props {
+    name: string;
+    description?: string;
+    status?: ResourceStatus;
+    image?: string;
+    location?: string;
+    specs?: ResourceSpec[];
+    tags?: string[];
+    nextAvailable?: string;
+    showBookAction?: boolean;
+    compact?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+    statusLabel?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        status?(_: {}): any;
+        status?(_: {}): any;
+        action?(_: {}): any;
+        action?(_: {}): any;
+        image?(_: {}): any;
+        specs?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: () => any;
+    book: () => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onClick?: (() => any) | undefined;
+    onBook?: (() => any) | undefined;
+}>, {
+    compact: boolean;
+    status: ResourceStatus;
+    size: "sm" | "md" | "lg";
+    tags: string[];
+    specs: ResourceSpec[];
+    showBookAction: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,26 @@
+import { TreeNode } from '../types';
+interface Props {
+    nodes: TreeNode[];
+    defaultExpandedIds?: string[];
+    expandAll?: boolean;
+    showIcons?: boolean;
+    showCounts?: boolean;
+    maxDepth?: number;
+    size?: 'sm' | 'md' | 'lg';
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    collapse: (nodeId: string) => any;
+    "node-click": (node: TreeNode) => any;
+    expand: (nodeId: string) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onCollapse?: ((nodeId: string) => any) | undefined;
+    "onNode-click"?: ((node: TreeNode) => any) | undefined;
+    onExpand?: ((nodeId: string) => any) | undefined;
+}>, {
+    size: "sm" | "md" | "lg";
+    showCounts: boolean;
+    defaultExpandedIds: string[];
+    expandAll: boolean;
+    showIcons: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,32 @@
+import { SampleType } from '../types';
+interface Props {
+    modelValue?: string;
+    samples: SampleType[];
+    showCounts?: boolean;
+    editable?: boolean;
+    colorPalette?: string[];
+    size?: 'sm' | 'md' | 'lg';
+    orientation?: 'vertical' | 'horizontal';
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (sampleId: string | undefined) => any;
+    "sample-click": (sample: SampleType) => any;
+    "sample-add": () => any;
+    "sample-remove": (sampleId: string) => any;
+    "color-change": (sampleId: string, color: string) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((sampleId: string | undefined) => any) | undefined;
+    "onSample-click"?: ((sample: SampleType) => any) | undefined;
+    "onSample-add"?: (() => any) | undefined;
+    "onSample-remove"?: ((sampleId: string) => any) | undefined;
+    "onColor-change"?: ((sampleId: string, color: string) => any) | undefined;
+}>, {
+    size: "sm" | "md" | "lg";
+    modelValue: string;
+    colorPalette: string[];
+    editable: boolean;
+    samples: SampleType[];
+    showCounts: boolean;
+    orientation: "vertical" | "horizontal";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,29 @@
+import { SampleGroup } from '../types';
+import { AutoGroupResult } from '../types/auto-group';
+interface Props {
+    samples: string[];
+    modelValue: string[];
+    groups?: SampleGroup[];
+    enableGrouping?: boolean;
+    enableSmartGroup?: boolean;
+    experimentId?: number;
+    designData?: Record<string, unknown>;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (samples: string[]) => any;
+    "update:groups": (groups: SampleGroup[]) => any;
+    smartGroup: (result: AutoGroupResult) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((samples: string[]) => any) | undefined;
+    "onUpdate:groups"?: ((groups: SampleGroup[]) => any) | undefined;
+    onSmartGroup?: ((result: AutoGroupResult) => any) | undefined;
+}>, {
+    experimentId: number;
+    designData: Record<string, unknown>;
+    groups: SampleGroup[];
+    enableGrouping: boolean;
+    enableSmartGroup: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    colorPickerInput: HTMLInputElement;
+}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,110 @@
+import { ScheduleView, ScheduleEvent, ScheduleBlockedSlot } from '../types/components';
+interface Props {
+    modelValue?: Date | string;
+    view?: ScheduleView;
+    events?: ScheduleEvent[];
+    dayStartHour?: number;
+    dayEndHour?: number;
+    slotDuration?: number;
+    showNowIndicator?: boolean;
+    readonly?: boolean;
+    blockedSlots?: ScheduleBlockedSlot[];
+    weekStartsOn?: 0 | 1;
+    showViewToggle?: boolean;
+    showNavigation?: boolean;
+    statusColors?: Record<string, string>;
+    locale?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        'day-header'?(_: {
+            date: Date;
+            isToday: boolean;
+        }): any;
+        'time-label'?(_: {
+            label: string;
+            index: number;
+        }): any;
+        event?(_: {
+            event: ScheduleEvent;
+        }): any;
+        'month-day'?(_: {
+            date: Date;
+            isToday: boolean;
+            events: ScheduleEvent[];
+        }): any;
+    };
+    refs: {
+        bodyRef: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: Date) => any;
+    navigate: (context: {
+        direction: string;
+        date: Date;
+    }) => any;
+    "update:view": (value: ScheduleView) => any;
+    "event-click": (event: ScheduleEvent) => any;
+    "event-create": (context: {
+        start: Date;
+        end: Date;
+    }) => any;
+    "event-update": (context: {
+        event: ScheduleEvent;
+        newStart: Date;
+        newEnd: Date;
+    }) => any;
+    "slot-click": (context: {
+        date: Date;
+        hour: number;
+        minute: number;
+    }) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: Date) => any) | undefined;
+    onNavigate?: ((context: {
+        direction: string;
+        date: Date;
+    }) => any) | undefined;
+    "onUpdate:view"?: ((value: ScheduleView) => any) | undefined;
+    "onEvent-click"?: ((event: ScheduleEvent) => any) | undefined;
+    "onEvent-create"?: ((context: {
+        start: Date;
+        end: Date;
+    }) => any) | undefined;
+    "onEvent-update"?: ((context: {
+        event: ScheduleEvent;
+        newStart: Date;
+        newEnd: Date;
+    }) => any) | undefined;
+    "onSlot-click"?: ((context: {
+        date: Date;
+        hour: number;
+        minute: number;
+    }) => any) | undefined;
+}>, {
+    view: ScheduleView;
+    readonly: boolean;
+    weekStartsOn: 0 | 1;
+    showNavigation: boolean;
+    locale: string;
+    events: ScheduleEvent[];
+    dayStartHour: number;
+    dayEndHour: number;
+    slotDuration: number;
+    showNowIndicator: boolean;
+    blockedSlots: ScheduleBlockedSlot[];
+    showViewToggle: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    bodyRef: HTMLDivElement;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,14 @@
+import { NumberNotation } from '../types';
+interface Props {
+    value: number;
+    precision?: number;
+    notation?: NumberNotation;
+    unit?: string;
+    copyable?: boolean;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    copyable: boolean;
+    precision: number;
+    notation: NumberNotation;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLSpanElement>;
+export default _default;

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

@@ -0,0 +1,20 @@
+import { SegmentedOption, SegmentedControlVariant, SegmentedControlSize } from '../types';
+interface Props {
+    modelValue: string | number;
+    options: SegmentedOption[];
+    variant?: SegmentedControlVariant;
+    size?: SegmentedControlSize;
+    fullWidth?: boolean;
+    disabled?: boolean;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string | number) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
+}>, {
+    disabled: boolean;
+    size: SegmentedControlSize;
+    variant: SegmentedControlVariant;
+    fullWidth: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;