@speckle/ui-components 2.23.7 → 2.23.9

package/dist/components/user/AvatarEditor.vue.d.ts

@@ -1,27 +1,243 @@
-import type { Nullable } from '@speckle/shared';
-import type { AvatarUser, UserAvatarSize } from '../../composables/user/avatar';
-declare const _default: import("vue").DefineComponent<__VLS_TypePropsToRuntimeProps<{
+import { Nullable } from '../../../../shared/dist/esm/index';
+import { UploadableFileItem } from '../../composables/form/fileUpload';
+import { AvatarUser, UserAvatarSize } from '../../composables/user/avatar';
+type __VLS_Props = {
     user: AvatarUser;
-    disabled?: boolean | undefined;
-    size?: UserAvatarSize | undefined;
-}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    cancel: () => void;
-    save: (val: Nullable<string>) => void;
-}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
-    user: AvatarUser;
-    disabled?: boolean | undefined;
-    size?: UserAvatarSize | undefined;
-}>>> & {
+    disabled?: boolean;
+    size?: UserAvatarSize;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    cancel: () => any;
+    save: (val: Nullable<string>) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
     onCancel?: (() => any) | undefined;
     onSave?: ((val: Nullable<string>) => any) | undefined;
-}, {}, {}>;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    cropper: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{} | {
+            [x: string]: any;
+        }> & Omit<{
+            readonly [x: string]: any;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>;
+        $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: string, ...args: any[]) => void;
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<any>, {
+            getResult: () => import('vue-advanced-cropper').CropperResult;
+            setCoordinates: (transform: import('vue-advanced-cropper').Transform | import('vue-advanced-cropper').Transform[]) => void;
+            refresh: () => void;
+            zoom: (factor: number, center?: import('vue-advanced-cropper').Point) => void;
+            move: (left: number, top?: number) => void;
+            rotate: (angle: number) => void;
+            flip: (horizontal: boolean, vertical?: boolean) => void;
+            reset: () => void;
+        }, {}, import('vue').ComputedOptions, import('vue').MethodOptions, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {} | {
+            [x: string]: any;
+        }, {}, 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<{}> & Omit<Readonly<any>, "reset" | "flip" | "rotate" | "getResult" | "setCoordinates" | "refresh" | "zoom" | "move"> & import('vue').ShallowUnwrapRef<{
+        getResult: () => import('vue-advanced-cropper').CropperResult;
+        setCoordinates: (transform: import('vue-advanced-cropper').Transform | import('vue-advanced-cropper').Transform[]) => void;
+        refresh: () => void;
+        zoom: (factor: number, center?: import('vue-advanced-cropper').Point) => void;
+        move: (left: number, top?: number) => void;
+        rotate: (angle: number) => void;
+        flip: (horizontal: boolean, vertical?: boolean) => void;
+        reset: () => void;
+    }> & {
+        [x: string]: never;
+    } & import('vue').MethodOptions & import('vue').ComponentCustomProperties & {}) | ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{} | {
+            [x: string]: any;
+        }> & Omit<{
+            readonly [x: string]: any;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>;
+        $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: string, ...args: any[]) => void;
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<any>, {
+            getResult: () => import('vue-advanced-cropper').CropperResult;
+            setCoordinates: (transform: import('vue-advanced-cropper').Transform | import('vue-advanced-cropper').Transform[]) => void;
+            refresh: () => void;
+            zoom: (factor: number, center?: import('vue-advanced-cropper').Point) => void;
+            move: (left: number, top?: number) => void;
+            rotate: (angle: number) => void;
+            flip: (horizontal: boolean, vertical?: boolean) => void;
+            reset: () => void;
+        }, {}, import('vue').ComputedOptions, import('vue').MethodOptions, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {} | {
+            [x: string]: any;
+        }, {}, 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<{
+        [x: string]: any;
+    }> & Omit<Readonly<any>, "reset" | "flip" | "rotate" | "getResult" | "setCoordinates" | "refresh" | "zoom" | "move"> & import('vue').ShallowUnwrapRef<{
+        getResult: () => import('vue-advanced-cropper').CropperResult;
+        setCoordinates: (transform: import('vue-advanced-cropper').Transform | import('vue-advanced-cropper').Transform[]) => void;
+        refresh: () => void;
+        zoom: (factor: number, center?: import('vue-advanced-cropper').Point) => void;
+        move: (left: number, top?: number) => void;
+        rotate: (angle: number) => void;
+        flip: (horizontal: boolean, vertical?: boolean) => void;
+        reset: () => void;
+    }> & {
+        [x: string]: never;
+    } & import('vue').MethodOptions & import('vue').ComponentCustomProperties & {}) | null;
+    uploadZone: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly accept?: string | undefined;
+            readonly multiple?: boolean | undefined;
+            readonly sizeLimit?: number | undefined;
+            readonly countLimit?: number | undefined;
+            readonly disabled?: boolean | undefined;
+            readonly "onFiles-selected"?: ((v: {
+                files: UploadableFileItem[];
+            }) => any) | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            fileUploadZone: HTMLDivElement;
+            fileInput: HTMLInputElement;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: "files-selected", v: {
+            files: UploadableFileItem[];
+        }) => void;
+        $el: HTMLDivElement;
+        $options: import('vue').ComponentOptionsBase<Readonly<{
+            accept?: string;
+            multiple?: boolean;
+            sizeLimit?: number;
+            countLimit?: number;
+            disabled?: boolean;
+        }> & Readonly<{
+            "onFiles-selected"?: ((v: {
+                files: UploadableFileItem[];
+            }) => any) | undefined;
+        }>, {
+            triggerPicker: () => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+            "files-selected": (v: {
+                files: UploadableFileItem[];
+            }) => any;
+        }, string, {
+            sizeLimit: number;
+        }, {}, 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<{
+        sizeLimit: number;
+    }> & Omit<Readonly<{
+        accept?: string;
+        multiple?: boolean;
+        sizeLimit?: number;
+        countLimit?: number;
+        disabled?: boolean;
+    }> & Readonly<{
+        "onFiles-selected"?: ((v: {
+            files: UploadableFileItem[];
+        }) => any) | undefined;
+    }>, "sizeLimit" | "triggerPicker"> & import('vue').ShallowUnwrapRef<{
+        triggerPicker: () => void;
+    }> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            default?(_: {
+                isDraggingFiles: boolean;
+                openFilePicker: () => void;
+                activatorOn: {
+                    click: () => void;
+                };
+            }): any;
+        };
+    }) | null;
+}, HTMLDivElement>;
 export default _default;
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToRuntimeProps<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
-    } : {
-        type: import('vue').PropType<T[K]>;
-        required: true;
-    };
-};

package/dist/components/user/AvatarGroup.vue.d.ts

@@ -1,55 +1,21 @@
-import type { UserAvatarSize, AvatarUserWithId } from '../../composables/user/avatar';
-declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+import { UserAvatarSize, AvatarUserWithId } from '../../composables/user/avatar';
+type __VLS_Props = {
     users: AvatarUserWithId[];
-    overlap?: boolean | undefined;
-    size?: UserAvatarSize | undefined;
-    maxCount?: number | undefined;
-    hideTooltips?: boolean | undefined;
-    maxAvatars?: number | undefined;
-}>, {
-    users: () => never[];
-    overlap: boolean;
-    size: string;
-    maxCount: undefined;
-    hideTooltips: boolean;
-    maxAvatars: undefined;
-}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
-    users: AvatarUserWithId[];
-    overlap?: boolean | undefined;
-    size?: UserAvatarSize | undefined;
-    maxCount?: number | undefined;
-    hideTooltips?: boolean | undefined;
-    maxAvatars?: number | undefined;
-}>, {
-    users: () => never[];
-    overlap: boolean;
-    size: string;
-    maxCount: undefined;
-    hideTooltips: boolean;
-    maxAvatars: undefined;
-}>>>, {
+    overlap?: boolean;
+    size?: UserAvatarSize;
+    maxCount?: number;
+    hideTooltips?: boolean;
+    maxAvatars?: number;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
     size: UserAvatarSize;
     users: AvatarUserWithId[];
     overlap: boolean;
     maxCount: number;
     hideTooltips: boolean;
     maxAvatars: number;
-}, {}>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    elementToWatchForChanges: HTMLDivElement;
+    itemContainer: HTMLDivElement;
+}, HTMLDivElement>;
 export default _default;
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToRuntimeProps<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
-    } : {
-        type: import('vue').PropType<T[K]>;
-        required: true;
-    };
-};
-type __VLS_WithDefaults<P, D> = {
-    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
-        default: D[K];
-    }> : P[K];
-};
-type __VLS_Prettify<T> = {
-    [K in keyof T]: T[K];
-} & {};

package/dist/composables/common/async.d.ts

@@ -1,6 +1,6 @@
-import { type MaybeAsync, buildManualPromise } from '@speckle/shared';
-import type { AsyncComputedOptions } from '@vueuse/core';
-import type { ComputedRef } from 'vue';
+import { MaybeAsync, buildManualPromise } from '../../../../shared/dist/esm/index';
+import { AsyncComputedOptions } from '@vueuse/core';
+import { ComputedRef } from 'vue';
 export interface AsyncWritableComputedOptions<T> {
     get: (...args: any[]) => MaybeAsync<T>;
     set: (value: T) => MaybeAsync<void>;

package/dist/composables/common/steps.d.ts

@@ -1,5 +1,5 @@
-import type { ToRefs } from 'vue';
-import type { HorizontalOrVertical, StepCoreType } from '../../helpers/common/components';
+import { ToRefs } from 'vue';
+import { HorizontalOrVertical, StepCoreType } from '../../helpers/common/components';
 import { TailwindBreakpoints } from '../../helpers/tailwind';
 export type StepsPadding = 'base' | 'xs' | 'sm';
 export declare function useStepsInternals(params: {
@@ -15,12 +15,12 @@ export declare function useStepsInternals(params: {
         (e: 'update:modelValue', val: number): void;
     };
 }): {
-    value: import("vue").WritableComputedRef<number>;
+    value: import('vue').WritableComputedRef<number, number>;
     isCurrentStep: (step: number) => boolean;
     isFinishedStep: (step: number) => boolean;
     switchStep: (newStep: number, e?: MouseEvent) => void;
     getStepDisplayValue: (step: number) => string;
-    listClasses: import("vue").ComputedRef<string>;
-    linkClasses: import("vue").ComputedRef<string>;
-    orientation: import("vue").ComputedRef<HorizontalOrVertical>;
+    listClasses: import('vue').ComputedRef<string>;
+    linkClasses: import('vue').ComputedRef<string>;
+    orientation: import('vue').ComputedRef<HorizontalOrVertical>;
 };

package/dist/composables/common/window.d.ts

@@ -1,5 +1,5 @@
-import type { Nullable } from '@speckle/shared';
-import type { MaybeRef } from '@vueuse/core';
+import { Nullable } from '../../../../shared/dist/esm/index';
+import { MaybeRef } from '@vueuse/core';
 export declare enum ThrottleOrDebounce {
     Throttle = 0,
     Debounce = 1
@@ -21,6 +21,6 @@ export declare function useResponsiveHorizontalDirectionCalculation(params: {
      */
     stopUpdatesBelowWidth?: MaybeRef<number>;
 }): {
-    direction: import("vue").ComputedRef<HorizontalDirection>;
+    direction: import('vue').ComputedRef<HorizontalDirection>;
     recalculateDirection: () => void;
 };

package/dist/composables/form/fileUpload.d.ts

@@ -1,6 +1,6 @@
-import type { MaybeRef } from '@vueuse/core';
-import type { MaybeNullOrUndefined, Nullable, Optional } from '@speckle/shared';
-import type { CSSProperties } from 'vue';
+import { MaybeRef } from '@vueuse/core';
+import { MaybeNullOrUndefined, Nullable, Optional } from '../../../../shared/dist/esm/index';
+import { CSSProperties } from 'vue';
 /**
  * A file, as emitted out from FileUploadZone
  */
@@ -57,7 +57,7 @@ export declare function usePrepareUploadableFiles(params: {
 export declare function useFileUploadProgressCore(params: {
     item: MaybeRef<MaybeNullOrUndefined<UploadFileItem>>;
 }): {
-    errorMessage: import("vue").ComputedRef<string | null>;
-    progressBarClasses: import("vue").ComputedRef<string>;
-    progressBarStyle: import("vue").ComputedRef<CSSProperties>;
+    errorMessage: import('vue').ComputedRef<string | null>;
+    progressBarClasses: import('vue').ComputedRef<string>;
+    progressBarStyle: import('vue').ComputedRef<CSSProperties>;
 };

package/dist/composables/form/input.d.ts

@@ -1,5 +1,5 @@
 import { ModifierKeys } from '../../helpers/form/input';
-import type { Ref } from 'vue';
+import { Ref } from 'vue';
 export type LabelPosition = 'top' | 'left';
 /**
  * onKeyDown wrapper that also checks for modifier keys being pressed
@@ -15,6 +15,6 @@ export declare function onKeyboardShortcut(modifiers: ModifierKeys[], key: strin
 export declare function useFormCheckboxModel(options?: Partial<{
     model: Ref<true | undefined>;
 }>): {
-    model: Ref<true | undefined>;
-    isChecked: import("vue").WritableComputedRef<boolean>;
+    model: Ref<true | undefined, true | undefined>;
+    isChecked: import('vue').WritableComputedRef<boolean, boolean>;
 };

package/dist/composables/form/select.d.ts

@@ -1,5 +1,5 @@
-import type { Ref, ToRefs } from 'vue';
-import type { Nullable } from '@speckle/shared';
+import { Ref, ToRefs } from 'vue';
+import { Nullable } from '../../../../shared/dist/esm/index';
 type GenericSelectValueType<T> = T | T[] | undefined;
 /**
  * Common setup for FormSelectBase wrapping selector components
@@ -20,8 +20,8 @@ export declare function useFormSelectChildInternals<T>(params: {
         itemContainer: Ref<Nullable<HTMLElement>>;
     };
 }): {
-    selectedValue: import("vue").WritableComputedRef<GenericSelectValueType<T>>;
-    hiddenSelectedItemCount: Ref<number>;
+    selectedValue: import('vue').WritableComputedRef<GenericSelectValueType<T>, GenericSelectValueType<T>>;
+    hiddenSelectedItemCount: Ref<number, number>;
     isArrayValue: (v: GenericSelectValueType<T>) => v is T[];
     isMultiItemArrayValue: (v: GenericSelectValueType<T>) => v is T[];
     firstItem: (v: NonNullable<GenericSelectValueType<T>>) => T;

package/dist/composables/form/textInput.d.ts

@@ -1,7 +1,7 @@
-import type { RuleExpression } from 'vee-validate';
-import type { Ref, ToRefs } from 'vue';
-import type { MaybeNullOrUndefined, Nullable } from '@speckle/shared';
-import type { LabelPosition } from './input';
+import { RuleExpression } from 'vee-validate';
+import { Ref, ToRefs } from 'vue';
+import { MaybeNullOrUndefined, Nullable } from '../../../../shared/dist/esm/index';
+import { LabelPosition } from './input';
 export type InputColor = 'page' | 'foundation' | 'transparent';
 /**
  * Common setup for text input & textarea fields
@@ -37,20 +37,20 @@ export declare function useTextInputCore<V extends string | string[] = string>(p
         customClear: () => void;
     }>;
 }): {
-    coreInputClasses: import("vue").ComputedRef<string>;
-    coreClasses: import("vue").ComputedRef<string>;
-    title: import("vue").ComputedRef<string>;
-    value: Ref<V>;
-    helpTipId: import("vue").ComputedRef<string | undefined>;
-    helpTipClasses: import("vue").ComputedRef<string>;
-    helpTip: import("vue").ComputedRef<string | undefined>;
-    hideHelpTip: import("vue").ComputedRef<boolean | "" | undefined>;
-    errorMessage: import("vue").ComputedRef<string | undefined>;
+    coreInputClasses: import('vue').ComputedRef<string>;
+    coreClasses: import('vue').ComputedRef<string>;
+    title: import('vue').ComputedRef<string>;
+    value: Ref<V, V>;
+    helpTipId: import('vue').ComputedRef<string | undefined>;
+    helpTipClasses: import('vue').ComputedRef<string>;
+    helpTip: import('vue').ComputedRef<string | undefined>;
+    hideHelpTip: import('vue').ComputedRef<boolean | "" | undefined>;
+    errorMessage: import('vue').ComputedRef<string | undefined>;
     clear: () => void;
     focus: () => void;
-    labelClasses: import("vue").ComputedRef<string>;
-    shouldShowClear: import("vue").ComputedRef<boolean>;
-    hasError: import("vue").ComputedRef<boolean>;
+    labelClasses: import('vue').ComputedRef<string>;
+    shouldShowClear: import('vue').ComputedRef<boolean>;
+    hasError: import('vue').ComputedRef<boolean>;
 };
 type FormInputChangeEvent = {
     event?: Event;
@@ -98,9 +98,9 @@ export declare function useDebouncedTextInput(params?: {
         change: (val: FormInputChangeEvent | Event) => void;
         keydown: (e: KeyboardEvent) => void;
     };
-    bind: import("vue").ComputedRef<{
+    bind: import('vue').ComputedRef<{
         modelValue: string;
     }>;
-    value: Ref<MaybeNullOrUndefined<string>>;
+    value: Ref<MaybeNullOrUndefined<string>, MaybeNullOrUndefined<string>>;
 };
 export {};

package/dist/composables/layout/resize.d.ts

@@ -1,5 +1,5 @@
-import type { Nullable } from '@speckle/shared';
-import type { Ref, ComputedRef } from 'vue';
+import { Nullable } from '../../../../shared/dist/esm/index';
+import { Ref, ComputedRef } from 'vue';
 /**
  * Use this to calculate the number of hidden elements (e.g. user avatars) in a wrapping flex row that
  * is styled to only show the first row. For example, there are 12 users total, there's only space for 5,
@@ -32,5 +32,5 @@ export declare function useWrappingContainerHiddenCount(params: {
      */
     trackMutations?: boolean;
 }): {
-    hiddenItemCount: Ref<number>;
+    hiddenItemCount: Ref<number, number>;
 };

package/dist/composables/testing.d.ts

@@ -1,4 +1,4 @@
-import type { StoryContext } from '@storybook/vue3';
+import { StoryContext } from '@storybook/vue3';
 /**
  * Composable for use in storybook to create a v-model binding that properly reports changes to the Actions tab
  * and also updates the model in the Controls tab
@@ -12,5 +12,5 @@ export declare const useStorybookVmodel: (params: {
      */
     blockChanges?: boolean;
 }) => {
-    model: import("vue").WritableComputedRef<unknown>;
+    model: import('vue').WritableComputedRef<unknown, unknown>;
 };

package/dist/composables/user/avatar.d.ts

@@ -1,4 +1,4 @@
-import type { ToRefs } from 'vue';
+import { ToRefs } from 'vue';
 export type AvatarUser = {
     name: string;
     avatar?: string | null;
@@ -12,8 +12,8 @@ export declare function useAvatarSizeClasses(params: {
         size?: UserAvatarSize;
     }>;
 }): {
-    heightClasses: import("vue").ComputedRef<"h-8" | "h-6" | "h-10" | "h-14" | "h-4" | "h-5" | "h-24" | "h-32" | "h-60">;
-    widthClasses: import("vue").ComputedRef<"w-4" | "w-5" | "w-6" | "w-10" | "w-14" | "w-24" | "w-32" | "w-60" | "w-8">;
-    sizeClasses: import("vue").ComputedRef<string>;
-    iconClasses: import("vue").ComputedRef<"w-4 h-4" | "w-3 h-3" | "w-5 h-5" | "w-8 h-8" | "w-10 h-10" | "w-20 h-20">;
+    heightClasses: import('vue').ComputedRef<"h-4" | "h-5" | "h-6" | "h-8" | "h-10" | "h-14" | "h-24" | "h-32" | "h-60">;
+    widthClasses: import('vue').ComputedRef<"w-6" | "w-10" | "w-8" | "w-4" | "w-5" | "w-14" | "w-24" | "w-32" | "w-60">;
+    sizeClasses: import('vue').ComputedRef<string>;
+    iconClasses: import('vue').ComputedRef<"w-4 h-4" | "w-3 h-3" | "w-5 h-5" | "w-8 h-8" | "w-10 h-10" | "w-20 h-20">;
 };

package/dist/directives/accessibility.d.ts

@@ -1,4 +1,4 @@
-import type { Directive } from 'vue';
+import { Directive } from 'vue';
 /**
  * Makes it possible to navigate to and click on the element using the keyboard
  */

package/dist/helpers/common/components.d.ts

@@ -1,4 +1,4 @@
-import type { ConcreteComponent, FunctionalComponent, DefineComponent } from 'vue';
+import { ConcreteComponent, FunctionalComponent, DefineComponent } from 'vue';
 export type PropAnyComponent = ConcreteComponent<any, any, any, any, any> | FunctionalComponent<any, any, any> | DefineComponent | string;
 export type HorizontalOrVertical = 'horizontal' | 'vertical';
 export interface StepCoreType {

package/dist/helpers/common/validation.d.ts

@@ -1,4 +1,4 @@
-import type { GenericValidateFunction } from 'vee-validate';
+import { GenericValidateFunction } from 'vee-validate';
 export declare const VALID_HTTP_URL: RegExp;
 export declare const VALID_EMAIL: RegExp;
 /**
@@ -27,4 +27,4 @@ export declare const stringContains: (params: {
 }) => GenericValidateFunction<string>;
 export declare const isUrl: GenericValidateFunction<string>;
 export declare const isItemSelected: GenericValidateFunction<unknown[]>;
-export declare const isMultiItemSelected: <T>(val: unknown) => true | string;
+export declare const isMultiItemSelected: <T>(val: T[] | unknown) => true | string;

package/dist/helpers/form/file.d.ts

@@ -1,5 +1,5 @@
-import type { Nullable } from '@speckle/shared';
-import { BaseError } from '../../helpers/common/error';
+import { Nullable } from '../../../../shared/dist/esm/index';
+import { BaseError } from '../common/error';
 export type FileTypeSpecifier = UniqueFileTypeSpecifier | `.${string}`;
 export declare enum UniqueFileTypeSpecifier {
     AnyAudio = "audio/*",

package/dist/helpers/form/input.d.ts

@@ -1,4 +1,4 @@
-import { OperatingSystem } from '@speckle/shared';
+import { OperatingSystem } from '../../../../shared/dist/esm/index';
 export declare enum ModifierKeys {
     CtrlOrCmd = "cmd-or-ctrl",
     AltOrOpt = "alt-or-opt",

package/dist/helpers/global/toast.d.ts

@@ -2,7 +2,8 @@ export declare enum ToastNotificationType {
     Success = 0,
     Warning = 1,
     Danger = 2,
-    Info = 3
+    Info = 3,
+    Loading = 4
 }
 export type ToastNotification = {
     title?: string;

package/dist/helpers/layout/components.d.ts

@@ -1,7 +1,7 @@
-import type { ConcreteComponent } from 'vue';
-import type { FormButton } from '../../lib';
+import { ConcreteComponent } from 'vue';
+import { FormButton } from '../../lib';
+import { PropAnyComponent } from '../common/components';
 type FormButtonProps = InstanceType<typeof FormButton>['$props'];
-import type { PropAnyComponent } from '../../helpers/common/components';
 export declare enum GridListToggleValue {
     Grid = "grid",
     List = "list"