@morscherlab/mint-sdk 1.0.0-alpha.2

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

@@ -0,0 +1,32 @@
+interface Props {
+    experimentName?: string;
+    experimentCode?: string;
+    experimentStatus?: string;
+    showSave?: boolean;
+    showDetach?: boolean;
+    saveDisabled?: boolean;
+    saveLoading?: boolean;
+    saveSuccessMessage?: string;
+    saveDisabledMessage?: string;
+    confirmSave?: boolean;
+    confirmTitle?: string;
+    confirmMessage?: string;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: () => any;
+    save: () => any;
+    detach: () => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onSelect?: (() => any) | undefined;
+    onSave?: (() => any) | undefined;
+    onDetach?: (() => any) | undefined;
+}>, {
+    showSave: boolean;
+    showDetach: boolean;
+    saveDisabled: boolean;
+    saveLoading: boolean;
+    confirmSave: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    popoverRef: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,28 @@
+import { ModalSize, ExperimentSummary } from '../types';
+interface Props {
+    modelValue: boolean;
+    experimentType?: string;
+    currentExperimentId?: number | null;
+    title?: string;
+    size?: ModalSize;
+    groupByProject?: boolean;
+    showFilters?: boolean;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (experiment: ExperimentSummary) => any;
+    "update:modelValue": (value: boolean) => any;
+    deselect: () => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onSelect?: ((experiment: ExperimentSummary) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    onDeselect?: (() => any) | undefined;
+}>, {
+    size: ModalSize;
+    title: string;
+    currentExperimentId: number | null;
+    groupByProject: boolean;
+    showFilters: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    listRef: HTMLDivElement;
+}, any>;
+export default _default;

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

@@ -0,0 +1,44 @@
+import { ProtocolStep, ProtocolStepStatus } from '../types';
+interface Props {
+    modelValue?: ProtocolStep[];
+    orientation?: 'horizontal' | 'vertical';
+    showDuration?: boolean;
+    showTime?: boolean;
+    editable?: boolean;
+    collapsible?: boolean;
+    expandedStepId?: string;
+    size?: 'sm' | 'md' | 'lg';
+    colorByStatus?: boolean;
+    colorByType?: boolean;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (steps: ProtocolStep[]) => any;
+    "step-click": (step: ProtocolStep) => any;
+    "step-expand": (stepId: string | undefined) => any;
+    "step-add": (afterStepId?: string | undefined) => any;
+    "step-remove": (stepId: string) => any;
+    "step-update": (step: ProtocolStep) => any;
+    "step-reorder": (stepId: string, newOrder: number) => any;
+    "step-status-change": (stepId: string, status: ProtocolStepStatus) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((steps: ProtocolStep[]) => any) | undefined;
+    "onStep-click"?: ((step: ProtocolStep) => any) | undefined;
+    "onStep-expand"?: ((stepId: string | undefined) => any) | undefined;
+    "onStep-add"?: ((afterStepId?: string | undefined) => any) | undefined;
+    "onStep-remove"?: ((stepId: string) => any) | undefined;
+    "onStep-update"?: ((step: ProtocolStep) => any) | undefined;
+    "onStep-reorder"?: ((stepId: string, newOrder: number) => any) | undefined;
+    "onStep-status-change"?: ((stepId: string, status: ProtocolStepStatus) => any) | undefined;
+}>, {
+    size: "sm" | "md" | "lg";
+    modelValue: ProtocolStep[];
+    editable: boolean;
+    orientation: "horizontal" | "vertical";
+    showDuration: boolean;
+    showTime: boolean;
+    collapsible: boolean;
+    expandedStepId: string;
+    colorByStatus: boolean;
+    colorByType: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,40 @@
+interface Props {
+    accept?: string;
+    multiple?: boolean;
+    maxSize?: number;
+    disabled?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+    mode?: 'file' | 'folder';
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        actions?(_: {}): any;
+    };
+    refs: {
+        inputRef: HTMLInputElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    error: (message: string) => any;
+    upload: (files: File[]) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onError?: ((message: string) => any) | undefined;
+    onUpload?: ((files: File[]) => any) | undefined;
+}>, {
+    disabled: boolean;
+    multiple: boolean;
+    size: "sm" | "md" | "lg";
+    mode: "file" | "folder";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    inputRef: HTMLInputElement;
+}, 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/FitPanel.vue.d.ts

@@ -0,0 +1,46 @@
+import { FitState, FitResultSummary } from '../types';
+interface Props {
+    state?: FitState;
+    progress?: number;
+    progressLabel?: string;
+    indeterminate?: boolean;
+    results?: FitResultSummary[];
+    errorMessage?: string;
+    runLabel?: string;
+    cancelLabel?: string;
+    disabled?: boolean;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        controls?(_: {}): any;
+        results?(_: {}): any;
+        footer?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    cancel: () => any;
+    run: () => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onCancel?: (() => any) | undefined;
+    onRun?: (() => any) | undefined;
+}>, {
+    disabled: boolean;
+    progress: number;
+    indeterminate: boolean;
+    state: FitState;
+    cancelLabel: string;
+    results: FitResultSummary[];
+    progressLabel: string;
+    runLabel: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, 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/FormActions.vue.d.ts

@@ -0,0 +1,33 @@
+interface Props {
+    isWizard?: boolean;
+    isFirst?: boolean;
+    isLast?: boolean;
+    canProceed?: boolean;
+    loading?: boolean;
+    disabled?: boolean;
+    submitLabel?: string;
+    cancelLabel?: string;
+    showCancel?: boolean;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    submit: () => any;
+    cancel: () => any;
+    next: () => any;
+    back: () => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onSubmit?: (() => any) | undefined;
+    onCancel?: (() => any) | undefined;
+    onNext?: (() => any) | undefined;
+    onBack?: (() => any) | undefined;
+}>, {
+    disabled: boolean;
+    loading: boolean;
+    cancelLabel: string;
+    canProceed: boolean;
+    isWizard: boolean;
+    isFirst: boolean;
+    isLast: boolean;
+    submitLabel: string;
+    showCancel: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,287 @@
+import { FormSchema, FormEnhancements, UseFormBuilderReturn } from '../types/form-builder';
+import { WizardStep } from '../types';
+interface Props {
+    schema: FormSchema;
+    modelValue?: Record<string, unknown>;
+    enhancements?: FormEnhancements<Record<string, unknown>>;
+    loading?: boolean;
+    disabled?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+    readonly?: boolean;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Partial<Record<`field:${string}`, (_: {
+        field: import('../types').FormFieldSchema;
+        form: import('../composables').UseFormReturn<Record<string, unknown>>;
+        fieldProps: {
+            modelValue: unknown;
+            'onUpdate:modelValue': (value: unknown) => void;
+            onBlur: () => void;
+            error: string | null;
+        };
+    }) => any>> & Partial<Record<`section:${string}`, (_: {
+        section: import('../types').FormSectionSchema;
+        form: import('../composables').UseFormReturn<Record<string, unknown>>;
+    }) => any>> & Partial<Record<`section:${string}:after`, (_: {
+        form: import('../composables').UseFormReturn<Record<string, unknown>>;
+    }) => any>> & Partial<Record<`field:${string}`, (_: {
+        field: import('../types').FormFieldSchema;
+        form: import('../composables').UseFormReturn<Record<string, unknown>>;
+        fieldProps: {
+            modelValue: unknown;
+            'onUpdate:modelValue': (value: unknown) => void;
+            onBlur: () => void;
+            error: string | null;
+        };
+    }) => any>> & Partial<Record<`section:${string}`, (_: {
+        section: import('../types').FormSectionSchema;
+        form: import('../composables').UseFormReturn<Record<string, unknown>>;
+    }) => any>> & Partial<Record<`section:${string}:after`, (_: {
+        form: import('../composables').UseFormReturn<Record<string, unknown>>;
+    }) => any>> & {
+        actions?(_: {
+            form: import('../composables').UseFormReturn<Record<string, unknown>>;
+            builder: UseFormBuilderReturn<Record<string, unknown>>;
+        }): any;
+        actions?(_: {
+            form: import('../composables').UseFormReturn<Record<string, unknown>>;
+            builder: UseFormBuilderReturn<Record<string, unknown>>;
+        }): any;
+    };
+    refs: {
+        wizardRef: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly steps: WizardStep[];
+                readonly modelValue?: number | undefined;
+                readonly linear?: boolean | undefined;
+                readonly showProgress?: boolean | undefined;
+                readonly showStepNumbers?: boolean | undefined;
+                readonly size?: "sm" | "md" | "lg" | undefined;
+                readonly "onUpdate:modelValue"?: ((index: number) => any) | undefined;
+                readonly onCancel?: (() => any) | undefined;
+                readonly onComplete?: (() => any) | undefined;
+                readonly "onStep-change"?: ((change: [from: number, to: number]) => any) | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "update:modelValue", index: number) => void) & ((event: "cancel") => void) & ((event: "complete") => void) & ((event: "step-change", change: [from: number, to: number]) => void);
+            $el: HTMLDivElement;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('./StepWizard.vue').Props> & Readonly<{
+                "onUpdate:modelValue"?: ((index: number) => any) | undefined;
+                onCancel?: (() => any) | undefined;
+                onComplete?: (() => any) | undefined;
+                "onStep-change"?: ((change: [from: number, to: number]) => any) | undefined;
+            }>, {
+                setStepValid: (index: number, valid: boolean) => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                "update:modelValue": (index: number) => any;
+                cancel: () => any;
+                complete: () => any;
+                "step-change": (change: [from: number, to: number]) => any;
+            }, string, {
+                size: "sm" | "md" | "lg";
+                modelValue: number;
+                linear: boolean;
+                showProgress: boolean;
+                showStepNumbers: boolean;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import('vue').nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+        } & Readonly<{
+            size: "sm" | "md" | "lg";
+            modelValue: number;
+            linear: boolean;
+            showProgress: boolean;
+            showStepNumbers: boolean;
+        }> & Omit<Readonly<import('./StepWizard.vue').Props> & Readonly<{
+            "onUpdate:modelValue"?: ((index: number) => any) | undefined;
+            onCancel?: (() => any) | undefined;
+            onComplete?: (() => any) | undefined;
+            "onStep-change"?: ((change: [from: number, to: number]) => any) | undefined;
+        }>, "setStepValid" | ("size" | "modelValue" | "linear" | "showProgress" | "showStepNumbers")> & import('vue').ShallowUnwrapRef<{
+            setStepValid: (index: number, valid: boolean) => void;
+        }> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: Partial<Record<`step-${string}`, (_: {
+                step: WizardStep;
+                index: number;
+            }) => any>> & {
+                progress?(_: {
+                    steps: WizardStep[];
+                    current: number;
+                    states: import('..').WizardStepState[];
+                }): any;
+                navigation?(_: {
+                    goBack: () => void;
+                    goNext: () => void;
+                    finish: () => void;
+                    cancel: () => void;
+                    isFirst: boolean;
+                    isLast: boolean;
+                    canProceed: boolean;
+                }): any;
+            };
+        }) | null;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {
+    form: import('../composables').UseFormReturn<Record<string, unknown>>;
+    validate: () => boolean;
+    reset: (values?: Partial<Record<string, unknown>> | undefined) => void;
+    goNext: () => boolean;
+    goBack: () => void;
+    goToStep: (index: number) => void;
+    builder: UseFormBuilderReturn<Record<string, unknown>>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    submit: (data: Record<string, unknown>) => any;
+    "update:modelValue": (data: Record<string, unknown>) => any;
+    cancel: () => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onSubmit?: ((data: Record<string, unknown>) => any) | undefined;
+    "onUpdate:modelValue"?: ((data: Record<string, unknown>) => any) | undefined;
+    onCancel?: (() => any) | undefined;
+}>, {
+    disabled: boolean;
+    loading: boolean;
+    readonly: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    wizardRef: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly steps: WizardStep[];
+            readonly modelValue?: number | undefined;
+            readonly linear?: boolean | undefined;
+            readonly showProgress?: boolean | undefined;
+            readonly showStepNumbers?: boolean | undefined;
+            readonly size?: "sm" | "md" | "lg" | undefined;
+            readonly "onUpdate:modelValue"?: ((index: number) => any) | undefined;
+            readonly onCancel?: (() => any) | undefined;
+            readonly onComplete?: (() => any) | undefined;
+            readonly "onStep-change"?: ((change: [from: number, to: number]) => any) | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "update:modelValue", index: number) => void) & ((event: "cancel") => void) & ((event: "complete") => void) & ((event: "step-change", change: [from: number, to: number]) => void);
+        $el: HTMLDivElement;
+        $options: import('vue').ComponentOptionsBase<Readonly<import('./StepWizard.vue').Props> & Readonly<{
+            "onUpdate:modelValue"?: ((index: number) => any) | undefined;
+            onCancel?: (() => any) | undefined;
+            onComplete?: (() => any) | undefined;
+            "onStep-change"?: ((change: [from: number, to: number]) => any) | undefined;
+        }>, {
+            setStepValid: (index: number, valid: boolean) => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            "update:modelValue": (index: number) => any;
+            cancel: () => any;
+            complete: () => any;
+            "step-change": (change: [from: number, to: number]) => any;
+        }, string, {
+            size: "sm" | "md" | "lg";
+            modelValue: number;
+            linear: boolean;
+            showProgress: boolean;
+            showStepNumbers: boolean;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import('vue').nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{
+        size: "sm" | "md" | "lg";
+        modelValue: number;
+        linear: boolean;
+        showProgress: boolean;
+        showStepNumbers: boolean;
+    }> & Omit<Readonly<import('./StepWizard.vue').Props> & Readonly<{
+        "onUpdate:modelValue"?: ((index: number) => any) | undefined;
+        onCancel?: (() => any) | undefined;
+        onComplete?: (() => any) | undefined;
+        "onStep-change"?: ((change: [from: number, to: number]) => any) | undefined;
+    }>, "setStepValid" | ("size" | "modelValue" | "linear" | "showProgress" | "showStepNumbers")> & import('vue').ShallowUnwrapRef<{
+        setStepValid: (index: number, valid: boolean) => void;
+    }> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: Partial<Record<`step-${string}`, (_: {
+            step: WizardStep;
+            index: number;
+        }) => any>> & {
+            progress?(_: {
+                steps: WizardStep[];
+                current: number;
+                states: import('..').WizardStepState[];
+            }): any;
+            navigation?(_: {
+                goBack: () => void;
+                goNext: () => void;
+                finish: () => void;
+                cancel: () => void;
+                isFirst: boolean;
+                isLast: boolean;
+                canProceed: boolean;
+            }): any;
+        };
+    }) | null;
+}, 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/FormField.vue.d.ts

@@ -0,0 +1,28 @@
+interface Props {
+    label?: string;
+    error?: string;
+    hint?: string;
+    required?: boolean;
+    showOptional?: boolean;
+    htmlFor?: string;
+    fieldId?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {
+            describedBy: string | undefined;
+        }): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, 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/FormFieldRenderer.vue.d.ts

@@ -0,0 +1,31 @@
+import { FormFieldSchema } from '../types/form-builder';
+import { UseFormReturn } from '../composables/useForm';
+interface Props {
+    field: FormFieldSchema;
+    resolvedProps: Record<string, unknown>;
+    form: UseFormReturn<Record<string, unknown>>;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Partial<Record<`field:${string}`, (_: {
+        field: FormFieldSchema;
+        form: UseFormReturn<Record<string, unknown>>;
+        fieldProps: {
+            modelValue: unknown;
+            'onUpdate:modelValue': (value: unknown) => void;
+            onBlur: () => void;
+            error: string | null;
+        };
+    }) => any>>;
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, 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/FormSection.vue.d.ts

@@ -0,0 +1,43 @@
+import { FormSectionSchema, UseFormBuilderReturn } from '../types/form-builder';
+interface Props {
+    section: FormSectionSchema;
+    builder: UseFormBuilderReturn<Record<string, unknown>>;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Partial<Record<`section:${string}`, (_: {
+        section: FormSectionSchema;
+        form: import('../composables').UseFormReturn<Record<string, unknown>>;
+    }) => any>> & Partial<Record<`field:${string}`, (_: {
+        field: import('../types').FormFieldSchema;
+        form: import('../composables').UseFormReturn<Record<string, unknown>>;
+        fieldProps: {
+            modelValue: unknown;
+            'onUpdate:modelValue': (value: unknown) => void;
+            onBlur: () => void;
+            error: string | null;
+        };
+    }) => any>> & Partial<Record<`field:${string}`, (_: {
+        field: import('../types').FormFieldSchema;
+        form: import('../composables').UseFormReturn<Record<string, unknown>>;
+        fieldProps: {
+            modelValue: unknown;
+            'onUpdate:modelValue': (value: unknown) => void;
+            onBlur: () => void;
+            error: string | null;
+        };
+    }) => any>> & Partial<Record<`section:${string}:after`, (_: {
+        form: import('../composables').UseFormReturn<Record<string, unknown>>;
+    }) => 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, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, 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/FormulaInput.vue.d.ts

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