@scalar/components 0.13.21 → 0.13.24

package/dist/components/ScalarFileUpload/ScalarFileUpload.stories.d.ts

@@ -0,0 +1,364 @@
+import type { StoryObj } from '@storybook/vue3';
+declare const meta: {
+    component: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
+            modelValue?: File[];
+            error?: string;
+        } & {
+            multiple?: boolean;
+            accept?: import("./types").ExtensionList | string;
+            loader?: import("../ScalarLoading").LoadingState;
+            variant?: "compact" | "default";
+        }> & Readonly<{
+            "onUpdate:modelValue"?: ((value: File[]) => any) | undefined;
+            onSelected?: ((value: File[]) => any) | undefined;
+            "onUpdate:error"?: ((value: string) => any) | undefined;
+        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            "update:modelValue": (value: File[]) => any;
+            "update:error": (value: string) => any;
+        } & {
+            selected: (value: File[]) => any;
+        }, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<{
+            modelValue?: File[];
+            error?: string;
+        } & {
+            multiple?: boolean;
+            accept?: import("./types").ExtensionList | string;
+            loader?: import("../ScalarLoading").LoadingState;
+            variant?: "compact" | "default";
+        }> & Readonly<{
+            "onUpdate:modelValue"?: ((value: File[]) => any) | undefined;
+            onSelected?: ((value: File[]) => any) | undefined;
+            "onUpdate:error"?: ((value: string) => any) | undefined;
+        }>, {}, {}, {}, {}, {}>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<{
+        modelValue?: File[];
+        error?: string;
+    } & {
+        multiple?: boolean;
+        accept?: import("./types").ExtensionList | string;
+        loader?: import("../ScalarLoading").LoadingState;
+        variant?: "compact" | "default";
+    }> & Readonly<{
+        "onUpdate:modelValue"?: ((value: File[]) => any) | undefined;
+        onSelected?: ((value: File[]) => any) | undefined;
+        "onUpdate:error"?: ((value: string) => any) | undefined;
+    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        "update:modelValue": (value: File[]) => any;
+        "update:error": (value: string) => any;
+    } & {
+        selected: (value: File[]) => any;
+    }, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: Readonly<{
+            default?: (props: {
+                open: () => void;
+            }) => any;
+            label?: () => any;
+            'drop-target'?: () => any;
+            'drop-target-label'?: () => any;
+        }> & {
+            default?: (props: {
+                open: () => void;
+            }) => any;
+            label?: () => any;
+            'drop-target'?: () => any;
+            'drop-target-label'?: () => any;
+        };
+    });
+    tags: string[];
+    argTypes: {
+        class: {
+            control: "text";
+        };
+        accept: {
+            control: "select";
+            options: string[][];
+        };
+        variant: {
+            control: "select";
+            options: string[];
+        };
+    };
+    render: (args: import("@storybook/vue3").ComponentPropsAndSlots<{
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
+            modelValue?: File[];
+            error?: string;
+        } & {
+            multiple?: boolean;
+            accept?: import("./types").ExtensionList | string;
+            loader?: import("../ScalarLoading").LoadingState;
+            variant?: "compact" | "default";
+        }> & Readonly<{
+            "onUpdate:modelValue"?: ((value: File[]) => any) | undefined;
+            onSelected?: ((value: File[]) => any) | undefined;
+            "onUpdate:error"?: ((value: string) => any) | undefined;
+        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            "update:modelValue": (value: File[]) => any;
+            "update:error": (value: string) => any;
+        } & {
+            selected: (value: File[]) => any;
+        }, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<{
+            modelValue?: File[];
+            error?: string;
+        } & {
+            multiple?: boolean;
+            accept?: import("./types").ExtensionList | string;
+            loader?: import("../ScalarLoading").LoadingState;
+            variant?: "compact" | "default";
+        }> & Readonly<{
+            "onUpdate:modelValue"?: ((value: File[]) => any) | undefined;
+            onSelected?: ((value: File[]) => any) | undefined;
+            "onUpdate:error"?: ((value: string) => any) | undefined;
+        }>, {}, {}, {}, {}, {}>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<{
+        modelValue?: File[];
+        error?: string;
+    } & {
+        multiple?: boolean;
+        accept?: import("./types").ExtensionList | string;
+        loader?: import("../ScalarLoading").LoadingState;
+        variant?: "compact" | "default";
+    }> & Readonly<{
+        "onUpdate:modelValue"?: ((value: File[]) => any) | undefined;
+        onSelected?: ((value: File[]) => any) | undefined;
+        "onUpdate:error"?: ((value: string) => any) | undefined;
+    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        "update:modelValue": (value: File[]) => any;
+        "update:error": (value: string) => any;
+    } & {
+        selected: (value: File[]) => any;
+    }, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: Readonly<{
+            default?: (props: {
+                open: () => void;
+            }) => any;
+            label?: () => any;
+            'drop-target'?: () => any;
+            'drop-target-label'?: () => any;
+        }> & {
+            default?: (props: {
+                open: () => void;
+            }) => any;
+            label?: () => any;
+            'drop-target'?: () => any;
+            'drop-target-label'?: () => any;
+        };
+    })>) => {
+        components: {
+            ScalarFileUpload: {
+                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
+                    modelValue?: File[];
+                    error?: string;
+                } & {
+                    multiple?: boolean;
+                    accept?: import("./types").ExtensionList | string;
+                    loader?: import("../ScalarLoading").LoadingState;
+                    variant?: "compact" | "default";
+                }> & Readonly<{
+                    "onUpdate:modelValue"?: ((value: File[]) => any) | undefined;
+                    onSelected?: ((value: File[]) => any) | undefined;
+                    "onUpdate:error"?: ((value: string) => any) | undefined;
+                }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                    "update:modelValue": (value: File[]) => any;
+                    "update:error": (value: string) => any;
+                } & {
+                    selected: (value: File[]) => any;
+                }, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<{
+                    modelValue?: File[];
+                    error?: string;
+                } & {
+                    multiple?: boolean;
+                    accept?: import("./types").ExtensionList | string;
+                    loader?: import("../ScalarLoading").LoadingState;
+                    variant?: "compact" | "default";
+                }> & Readonly<{
+                    "onUpdate:modelValue"?: ((value: File[]) => any) | undefined;
+                    onSelected?: ((value: File[]) => any) | undefined;
+                    "onUpdate:error"?: ((value: string) => any) | undefined;
+                }>, {}, {}, {}, {}, {}>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import("vue").ComponentOptionsBase<Readonly<{
+                modelValue?: File[];
+                error?: string;
+            } & {
+                multiple?: boolean;
+                accept?: import("./types").ExtensionList | string;
+                loader?: import("../ScalarLoading").LoadingState;
+                variant?: "compact" | "default";
+            }> & Readonly<{
+                "onUpdate:modelValue"?: ((value: File[]) => any) | undefined;
+                onSelected?: ((value: File[]) => any) | undefined;
+                "onUpdate:error"?: ((value: string) => any) | undefined;
+            }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                "update:modelValue": (value: File[]) => any;
+                "update:error": (value: string) => any;
+            } & {
+                selected: (value: File[]) => any;
+            }, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+                $slots: Readonly<{
+                    default?: (props: {
+                        open: () => void;
+                    }) => any;
+                    label?: () => any;
+                    'drop-target'?: () => any;
+                    'drop-target-label'?: () => any;
+                }> & {
+                    default?: (props: {
+                        open: () => void;
+                    }) => any;
+                    label?: () => any;
+                    'drop-target'?: () => any;
+                    'drop-target-label'?: () => any;
+                };
+            });
+            ScalarFileUploadFileList: import("vue").DefineComponent<{
+                modelValue?: File[];
+            }, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                "update:modelValue": (value: File[]) => any;
+            } & {
+                upload: () => any;
+            }, string, import("vue").PublicProps, Readonly<{
+                modelValue?: File[];
+            }> & Readonly<{
+                "onUpdate:modelValue"?: ((value: File[]) => any) | undefined;
+                onUpload?: (() => any) | undefined;
+            }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+        };
+        setup(this: void): {
+            args: import("@storybook/vue3").ComponentPropsAndSlots<{
+                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
+                    modelValue?: File[];
+                    error?: string;
+                } & {
+                    multiple?: boolean;
+                    accept?: import("./types").ExtensionList | string;
+                    loader?: import("../ScalarLoading").LoadingState;
+                    variant?: "compact" | "default";
+                }> & Readonly<{
+                    "onUpdate:modelValue"?: ((value: File[]) => any) | undefined;
+                    onSelected?: ((value: File[]) => any) | undefined;
+                    "onUpdate:error"?: ((value: string) => any) | undefined;
+                }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                    "update:modelValue": (value: File[]) => any;
+                    "update:error": (value: string) => any;
+                } & {
+                    selected: (value: File[]) => any;
+                }, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<{
+                    modelValue?: File[];
+                    error?: string;
+                } & {
+                    multiple?: boolean;
+                    accept?: import("./types").ExtensionList | string;
+                    loader?: import("../ScalarLoading").LoadingState;
+                    variant?: "compact" | "default";
+                }> & Readonly<{
+                    "onUpdate:modelValue"?: ((value: File[]) => any) | undefined;
+                    onSelected?: ((value: File[]) => any) | undefined;
+                    "onUpdate:error"?: ((value: string) => any) | undefined;
+                }>, {}, {}, {}, {}, {}>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import("vue").ComponentOptionsBase<Readonly<{
+                modelValue?: File[];
+                error?: string;
+            } & {
+                multiple?: boolean;
+                accept?: import("./types").ExtensionList | string;
+                loader?: import("../ScalarLoading").LoadingState;
+                variant?: "compact" | "default";
+            }> & Readonly<{
+                "onUpdate:modelValue"?: ((value: File[]) => any) | undefined;
+                onSelected?: ((value: File[]) => any) | undefined;
+                "onUpdate:error"?: ((value: string) => any) | undefined;
+            }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                "update:modelValue": (value: File[]) => any;
+                "update:error": (value: string) => any;
+            } & {
+                selected: (value: File[]) => any;
+            }, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+                $slots: Readonly<{
+                    default?: (props: {
+                        open: () => void;
+                    }) => any;
+                    label?: () => any;
+                    'drop-target'?: () => any;
+                    'drop-target-label'?: () => any;
+                }> & {
+                    default?: (props: {
+                        open: () => void;
+                    }) => any;
+                    label?: () => any;
+                    'drop-target'?: () => any;
+                    'drop-target-label'?: () => any;
+                };
+            })>;
+            files: import("vue").Ref<{
+                readonly lastModified: number;
+                readonly name: string;
+                readonly webkitRelativePath: string;
+                readonly size: number;
+                readonly type: string;
+                arrayBuffer: () => Promise<ArrayBuffer>;
+                slice: (start?: number, end?: number, contentType?: string) => Blob;
+                stream: () => ReadableStream<Uint8Array>;
+                text: () => Promise<string>;
+            }[], File[] | {
+                readonly lastModified: number;
+                readonly name: string;
+                readonly webkitRelativePath: string;
+                readonly size: number;
+                readonly type: string;
+                arrayBuffer: () => Promise<ArrayBuffer>;
+                slice: (start?: number, end?: number, contentType?: string) => Blob;
+                stream: () => ReadableStream<Uint8Array>;
+                text: () => Promise<string>;
+            }[]>;
+        };
+        template: string;
+    };
+};
+export default meta;
+type Story = StoryObj<typeof meta>;
+export declare const Base: Story;
+export declare const Compact: Story;
+export declare const Files: Story;
+export declare const Loading: Story;
+export declare const Labelled: Story;
+//# sourceMappingURL=ScalarFileUpload.stories.d.ts.map

package/dist/components/ScalarFileUpload/ScalarFileUpload.stories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScalarFileUpload.stories.d.ts","sourceRoot":"","sources":["../../../src/components/ScalarFileUpload/ScalarFileUpload.stories.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAQ,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAOrD,QAAA,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqC+B,CAAA;AAEzC,eAAe,IAAI,CAAA;AACnB,KAAK,KAAK,GAAG,QAAQ,CAAC,OAAO,IAAI,CAAC,CAAA;AAElC,eAAO,MAAM,IAAI,EAAE,KAAU,CAAA;AAE7B,eAAO,MAAM,OAAO,EAAE,KAErB,CAAA;AAED,eAAO,MAAM,KAAK,EAAE,KAsBnB,CAAA;AACD,eAAO,MAAM,OAAO,EAAE,KAiBrB,CAAA;AAED,eAAO,MAAM,QAAQ,EAAE,KAqBtB,CAAA"}

package/dist/components/ScalarFileUpload/ScalarFileUpload.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ScalarFileUpload.test.d.ts.map

package/dist/components/ScalarFileUpload/ScalarFileUpload.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScalarFileUpload.test.d.ts","sourceRoot":"","sources":["../../../src/components/ScalarFileUpload/ScalarFileUpload.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,86 @@
+import type { LoadingState } from '../ScalarLoading';
+import { type ExtensionList } from './types';
+/**
+ * Scalar File Upload component
+ *
+ * @example
+ * <ScalarFileUpload @selected="handleSelected" />
+ *
+ * @example
+ * <ScalarFileUpload v-slot="{ open }">
+ *   <ScalarButton @click="open">Select files</ScalarButton>
+ * </ScalarFileUpload>
+ */
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
+    modelValue?: File[];
+    error?: string;
+} & {
+    /** Whether multiple files can be uploaded */
+    multiple?: boolean;
+    /**
+     * Accepted file types
+     * @default '*'
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/accept
+     */
+    accept?: ExtensionList | string;
+    /** Whether the file upload is loading */
+    loader?: LoadingState;
+    /** Whether the file upload is compact */
+    variant?: "compact" | "default";
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: File[]) => any;
+    "update:error": (value: string) => any;
+} & {
+    selected: (value: File[]) => any;
+}, string, import("vue").PublicProps, Readonly<{
+    modelValue?: File[];
+    error?: string;
+} & {
+    /** Whether multiple files can be uploaded */
+    multiple?: boolean;
+    /**
+     * Accepted file types
+     * @default '*'
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/accept
+     */
+    accept?: ExtensionList | string;
+    /** Whether the file upload is loading */
+    loader?: LoadingState;
+    /** Whether the file upload is compact */
+    variant?: "compact" | "default";
+}> & Readonly<{
+    "onUpdate:modelValue"?: ((value: File[]) => any) | undefined;
+    onSelected?: ((value: File[]) => any) | undefined;
+    "onUpdate:error"?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, Readonly<{
+    /** Override the entire input */
+    default?: (props: {
+        /** Open the file dialog to select files */
+        open: () => void;
+    }) => any;
+    /** Override the label */
+    label?: () => any;
+    /** Override the entire drop target */
+    'drop-target'?: () => any;
+    /** Override the drop target label */
+    'drop-target-label'?: () => any;
+}> & {
+    /** Override the entire input */
+    default?: (props: {
+        /** Open the file dialog to select files */
+        open: () => void;
+    }) => any;
+    /** Override the label */
+    label?: () => any;
+    /** Override the entire drop target */
+    'drop-target'?: () => any;
+    /** Override the drop target label */
+    'drop-target-label'?: () => any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=ScalarFileUpload.vue.d.ts.map

package/dist/components/ScalarFileUpload/ScalarFileUpload.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScalarFileUpload.vue.d.ts","sourceRoot":"","sources":["../../../src/components/ScalarFileUpload/ScalarFileUpload.vue"],"names":[],"mappings":"AAkLA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAMpD,OAAO,EAAE,KAAK,aAAa,EAAmB,MAAM,SAAS,CAAA;AAI7D;;;;;;;;;;GAUG;;iBAwGU,IAAI,EAAE;YACT,MAAM;;IArGd,6CAA6C;eAClC,OAAO;IAClB;;;;OAIG;aACM,aAAa,GAAG,MAAM;IAC/B,yCAAyC;aAChC,YAAY;IACrB,yCAAyC;cAC/B,SAAS,GAAG,SAAS;;;;;;;iBAyFpB,IAAI,EAAE;YACT,MAAM;;IArGd,6CAA6C;eAClC,OAAO;IAClB;;;;OAIG;aACM,aAAa,GAAG,MAAM;IAC/B,yCAAyC;aAChC,YAAY;IACrB,yCAAyC;cAC/B,SAAS,GAAG,SAAS;;;;;;IAgB/B,gCAAgC;cACpB,CAAC,KAAK,EAAE;QAClB,2CAA2C;QAC3C,IAAI,EAAE,MAAM,IAAI,CAAA;KACjB,KAAK,GAAG;IACT,yBAAyB;YACf,MAAM,GAAG;IACnB,sCAAsC;oBACtB,MAAM,GAAG;IACzB,qCAAqC;0BACf,MAAM,GAAG;;IAV/B,gCAAgC;cACpB,CAAC,KAAK,EAAE;QAClB,2CAA2C;QAC3C,IAAI,EAAE,MAAM,IAAI,CAAA;KACjB,KAAK,GAAG;IACT,yBAAyB;YACf,MAAM,GAAG;IACnB,sCAAsC;oBACtB,MAAM,GAAG;IACzB,qCAAqC;0BACf,MAAM,GAAG;;AAxCjC,wBA8QC;AAWD,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/dist/components/ScalarFileUpload/ScalarFileUploadDropTarget.vue.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Scalar File Upload Drop Target
+ *
+ * Displays a drop target for file uploads (used when
+ * the user is dragging files over the component)
+ *
+ * @example
+ * <ScalarFileUploadDropTarget />
+ */
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=ScalarFileUploadDropTarget.vue.d.ts.map

package/dist/components/ScalarFileUpload/ScalarFileUploadDropTarget.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScalarFileUploadDropTarget.vue.d.ts","sourceRoot":"","sources":["../../../src/components/ScalarFileUpload/ScalarFileUploadDropTarget.vue"],"names":[],"mappings":"AA0CA;;;;;;;;GAQG;;qBA4D0B,GAAG;;AA3DhC,wBA0FC;AAKD,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/dist/components/ScalarFileUpload/ScalarFileUploadError.vue.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Scalar File Upload Error
+ *
+ * Displays an error message
+ *
+ * @example
+ * <ScalarFileUploadError>
+ *   <!-- Error message -->
+ * </ScalarFileUploadError>
+ */
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=ScalarFileUploadError.vue.d.ts.map

package/dist/components/ScalarFileUpload/ScalarFileUploadError.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScalarFileUploadError.vue.d.ts","sourceRoot":"","sources":["../../../src/components/ScalarFileUpload/ScalarFileUploadError.vue"],"names":[],"mappings":"AAmCA;;;;;;;;;GASG;;qBA2C0B,GAAG;;AA1ChC,wBAyEC;AAKD,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/dist/components/ScalarFileUpload/ScalarFileUploadFileList.vue.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Scalar File Upload File List
+ *
+ * Displays a list of files
+ *
+ * @example
+ * <ScalarFileUploadFileList :files="files" />
+ */
+declare const _default: import("vue").DefineComponent<{
+    modelValue?: File[];
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: File[]) => any;
+} & {
+    upload: () => any;
+}, string, import("vue").PublicProps, Readonly<{
+    modelValue?: File[];
+}> & Readonly<{
+    "onUpdate:modelValue"?: ((value: File[]) => any) | undefined;
+    onUpload?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;
+//# sourceMappingURL=ScalarFileUploadFileList.vue.d.ts.map

package/dist/components/ScalarFileUpload/ScalarFileUploadFileList.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScalarFileUploadFileList.vue.d.ts","sourceRoot":"","sources":["../../../src/components/ScalarFileUpload/ScalarFileUploadFileList.vue"],"names":[],"mappings":"AAoEA;;;;;;;GAOG;;iBAuBU,IAAI,EAAE;;;;;;iBAAN,IAAI,EAAE;;;;;AAtBnB,wBAmKC"}

package/dist/components/ScalarFileUpload/ScalarFileUploadInput.vue.d.ts

@@ -0,0 +1,21 @@
+import type { FileUploadInputProps, FileUploadInputSlots } from './types';
+/**
+ * Scalar File Upload Input
+ *
+ * Displays a label and button for file uploads
+ *
+ * @example
+ * <ScalarFileUploadInput />
+ */
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<FileUploadInputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    click: (event: MouseEvent) => any;
+}, string, import("vue").PublicProps, Readonly<FileUploadInputProps> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, Readonly<FileUploadInputSlots> & FileUploadInputSlots>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=ScalarFileUploadInput.vue.d.ts.map

package/dist/components/ScalarFileUpload/ScalarFileUploadInput.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScalarFileUploadInput.vue.d.ts","sourceRoot":"","sources":["../../../src/components/ScalarFileUpload/ScalarFileUploadInput.vue"],"names":[],"mappings":"AAwDA,OAAO,KAAK,EAEV,oBAAoB,EACpB,oBAAoB,EACrB,MAAM,SAAS,CAAA;AAIhB;;;;;;;GAOG;;;;;;AACH,wBAuHC;AAWD,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/dist/components/ScalarFileUpload/ScalarFileUploadInputCompact.vue.d.ts

@@ -0,0 +1,21 @@
+import type { FileUploadInputProps, FileUploadInputSlots } from './types';
+/**
+ * Scalar File Upload Input
+ *
+ * Displays a label and button for file uploads
+ *
+ * @example
+ * <ScalarFileUploadInput />
+ */
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<FileUploadInputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    click: (event: MouseEvent) => any;
+}, string, import("vue").PublicProps, Readonly<FileUploadInputProps> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, Readonly<FileUploadInputSlots> & FileUploadInputSlots>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=ScalarFileUploadInputCompact.vue.d.ts.map

package/dist/components/ScalarFileUpload/ScalarFileUploadInputCompact.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScalarFileUploadInputCompact.vue.d.ts","sourceRoot":"","sources":["../../../src/components/ScalarFileUpload/ScalarFileUploadInputCompact.vue"],"names":[],"mappings":"AAyDA,OAAO,KAAK,EAEV,oBAAoB,EACpB,oBAAoB,EACrB,MAAM,SAAS,CAAA;AAIhB;;;;;;;GAOG;;;;;;AACH,wBAuGC;AAWD,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/dist/components/ScalarFileUpload/ScalarFileUploadLoading.vue.d.ts

@@ -0,0 +1,16 @@
+import { type LoadingState } from '../ScalarLoading';
+/**
+ * Scalar File Upload Loading
+ *
+ * Displays a loading state for file uploads
+ *
+ * @example
+ * <ScalarFileUploadLoading :loader="loader" />
+ */
+declare const _default: import("vue").DefineComponent<{
+    loader: LoadingState;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
+    loader: LoadingState;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;
+//# sourceMappingURL=ScalarFileUploadLoading.vue.d.ts.map

package/dist/components/ScalarFileUpload/ScalarFileUploadLoading.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScalarFileUploadLoading.vue.d.ts","sourceRoot":"","sources":["../../../src/components/ScalarFileUpload/ScalarFileUploadLoading.vue"],"names":[],"mappings":"AAqCA,OAAO,EAAE,KAAK,YAAY,EAAiB,MAAM,kBAAkB,CAAA;AAInE;;;;;;;GAOG;;YAIO,YAAY;;YAAZ,YAAY;;AAHtB,wBAgFC"}

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

@@ -0,0 +1,8 @@
+export { default as ScalarFileUpload } from './ScalarFileUpload.vue';
+export { default as ScalarFileUploadInput } from './ScalarFileUploadInput.vue';
+export { default as ScalarFileUploadInputCompact } from './ScalarFileUploadInputCompact.vue';
+export { default as ScalarFileUploadDropTarget } from './ScalarFileUploadDropTarget.vue';
+export { default as ScalarFileUploadLoading } from './ScalarFileUploadLoading.vue';
+export { default as ScalarFileUploadError } from './ScalarFileUploadError.vue';
+export { default as ScalarFileUploadFileList } from './ScalarFileUploadFileList.vue';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/ScalarFileUpload/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/ScalarFileUpload/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AACpE,OAAO,EAAE,OAAO,IAAI,qBAAqB,EAAE,MAAM,6BAA6B,CAAA;AAC9E,OAAO,EAAE,OAAO,IAAI,4BAA4B,EAAE,MAAM,oCAAoC,CAAA;AAC5F,OAAO,EAAE,OAAO,IAAI,0BAA0B,EAAE,MAAM,kCAAkC,CAAA;AACxF,OAAO,EAAE,OAAO,IAAI,uBAAuB,EAAE,MAAM,+BAA+B,CAAA;AAClF,OAAO,EAAE,OAAO,IAAI,qBAAqB,EAAE,MAAM,6BAA6B,CAAA;AAC9E,OAAO,EAAE,OAAO,IAAI,wBAAwB,EAAE,MAAM,gCAAgC,CAAA"}