@knime/scripting-editor 0.0.106 → 0.0.108

package/dist/message-datatype-C9-EmnSB-DqyiLZm4.js

@@ -0,0 +1,22 @@
+import { createElementBlock as o, openBlock as t, createElementVNode as n } from "vue";
+const r = {
+  xmlns: "http://www.w3.org/2000/svg",
+  fill: "none",
+  stroke: "currentColor",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  viewBox: "0 0 12 12"
+};
+function l(c, e) {
+  return t(), o("svg", r, e[0] || (e[0] = [
+    n("path", {
+      d: "M3.75 4h4m-4 1.984H6m-1.088 3.36L3.75 10V8.588h-1c-.398 0-.78-.148-1.06-.413a1.37 1.37 0 0 1-.44-.999V3.412c0-.375.158-.734.44-.998A1.55 1.55 0 0 1 2.75 2h6c.398 0 .78.149 1.06.414.282.264.44.623.44.998v2.117M8.75 7l-.564 1.436L6.75 9l1.436.564L8.75 11l.564-1.436L10.75 9l-1.436-.564z",
+      "vector-effect": "non-scaling-stroke"
+    }, null, -1)
+  ]));
+}
+const a = { render: l };
+export {
+  a as default,
+  l as render
+};

package/dist/metanode-DtkJqhjE-Clj0bnmY.js

@@ -0,0 +1,22 @@
+import { createElementBlock as o, openBlock as n, createElementVNode as t } from "vue";
+const r = {
+  xmlns: "http://www.w3.org/2000/svg",
+  fill: "none",
+  stroke: "currentColor",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  viewBox: "0 0 12 12"
+};
+function m(l, e) {
+  return n(), o("svg", r, e[0] || (e[0] = [
+    t("path", {
+      d: "M6 6v2m0-2H4m2 0V4m0 2h2M1.5 3v-.75a.75.75 0 0 1 .75-.75H3m6 0h.75a.75.75 0 0 1 .75.75V3m0 6v.75a.75.75 0 0 1-.75.75H9m-6 0h-.75a.75.75 0 0 1-.75-.75V9m0-2V5m9 0v2M7 10.5H5m0-9h2",
+      "vector-effect": "non-scaling-stroke"
+    }, null, -1)
+  ]));
+}
+const a = { render: m };
+export {
+  a as default,
+  m as render
+};

package/dist/microscope-DS6bN3jk-h146aLkM.js

@@ -0,0 +1,22 @@
+import { createElementBlock as o, openBlock as n, createElementVNode as r } from "vue";
+const t = {
+  xmlns: "http://www.w3.org/2000/svg",
+  fill: "none",
+  stroke: "currentColor",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  viewBox: "0 0 12 12"
+};
+function l(c, e) {
+  return n(), o("svg", t, e[0] || (e[0] = [
+    r("path", {
+      d: "M2 10.5h7.467M2.533 9H3.6m-.533 0v1.5m1.866-4.25-.8.75M8.4 1.5 10 3m-4.267 7.5c.665 0 1.314-.194 1.856-.556.542-.361.95-.872 1.168-1.461s.235-1.227.048-1.826a3 3 0 0 0-1.09-1.513M4.133 5.5l1.6 1.5 3.2-3-1.6-1.5z",
+      "vector-effect": "non-scaling-stroke"
+    }, null, -1)
+  ]));
+}
+const i = { render: l };
+export {
+  i as default,
+  l as render
+};

package/dist/minus-CjUP6_Q8-CRcR7Lhz.js

@@ -0,0 +1,21 @@
+import { createElementBlock as o, openBlock as t, createElementVNode as n } from "vue";
+const r = {
+  xmlns: "http://www.w3.org/2000/svg",
+  fill: "none",
+  stroke: "currentColor",
+  "stroke-linecap": "round",
+  viewBox: "0 0 12 12"
+};
+function l(s, e) {
+  return t(), o("svg", r, e[0] || (e[0] = [
+    n("path", {
+      d: "M2.5 6h7",
+      "vector-effect": "non-scaling-stroke"
+    }, null, -1)
+  ]));
+}
+const i = { render: l };
+export {
+  i as default,
+  l as render
+};

package/dist/model-pmml-datatype-94e99we--DlRQACuj.js

@@ -0,0 +1,22 @@
+import { createElementBlock as o, openBlock as t, createElementVNode as n } from "vue";
+const r = {
+  xmlns: "http://www.w3.org/2000/svg",
+  fill: "none",
+  stroke: "currentColor",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  viewBox: "0 0 12 12"
+};
+function l(a, e) {
+  return t(), o("svg", r, e[0] || (e[0] = [
+    n("path", {
+      d: "M7.556 6.444A1.556 1.556 0 0 0 6 8m0 0v.444M6 8a1.556 1.556 0 0 0-1.556-1.556M6 8V3.556m0 4.888a1.556 1.556 0 0 0 3.111 0v-.8M6 8.444a1.556 1.556 0 0 1-3.111 0v-.8m5.555.134a1.556 1.556 0 0 0 0-3.111h-.222m.89.133V3.556a1.556 1.556 0 0 0-3.112 0m0 0a1.556 1.556 0 0 0-3.111 0V4.8m.667 2.978a1.556 1.556 0 0 1 0-3.111h.222",
+      "vector-effect": "non-scaling-stroke"
+    }, null, -1)
+  ]));
+}
+const s = { render: l };
+export {
+  s as default,
+  l as render
+};

package/dist/molecule-eT_tgLRf-ypw8MLo7.js

@@ -0,0 +1,22 @@
+import { createElementBlock as o, openBlock as n, createElementVNode as t } from "vue";
+const r = {
+  xmlns: "http://www.w3.org/2000/svg",
+  fill: "none",
+  stroke: "currentColor",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  viewBox: "0 0 12 12"
+};
+function l(m, e) {
+  return n(), o("svg", r, e[0] || (e[0] = [
+    t("path", {
+      d: "M3.622 5.563V3.375l1.72-.875 1.72.875m-3.44 2.188 1.72.875m-1.72-.875L1.5 6.82m3.842-.383 1.72-.875m-1.72.875v2.188l1.72.875 1.719-.875V6.438m-1.72-.875V3.375m0 2.188 1.72.875M7.06 3.375 8.78 2.5m0 3.938 1.719-.875",
+      "vector-effect": "non-scaling-stroke"
+    }, null, -1)
+  ]));
+}
+const s = { render: l };
+export {
+  s as default,
+  l as render
+};

package/dist/more-actions-DBLTo2NK-D_qPYTyZ.js

@@ -0,0 +1,22 @@
+import { createElementBlock as o, openBlock as n, createElementVNode as t } from "vue";
+const r = {
+  xmlns: "http://www.w3.org/2000/svg",
+  fill: "none",
+  stroke: "currentColor",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  viewBox: "0 0 12 12"
+};
+function l(m, e) {
+  return n(), o("svg", r, e[0] || (e[0] = [
+    t("path", {
+      d: "M2.5 5.5v1m-.354-.854.708.708m0-.708-.708.708M2 6h1m3-.5v1m-.354-.854.708.708m0-.708-.708.708M5.5 6h1m3-.5v1m-.354-.854.708.708m0-.708-.708.708M9 6h1",
+      "vector-effect": "non-scaling-stroke"
+    }, null, -1)
+  ]));
+}
+const c = { render: l };
+export {
+  c as default,
+  l as render
+};

package/dist/node-stack-B1tUffrH-C01m1uIq.js

@@ -0,0 +1,22 @@
+import { createElementBlock as o, openBlock as n, createElementVNode as t } from "vue";
+const r = {
+  xmlns: "http://www.w3.org/2000/svg",
+  fill: "none",
+  stroke: "currentColor",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round",
+  viewBox: "0 0 12 12"
+};
+function a(l, e) {
+  return n(), o("svg", r, e[0] || (e[0] = [
+    t("path", {
+      d: "M7.085 10.585a.56.56 0 0 1-.397.165H1.813a.564.564 0 0 1-.563-.562V5.312a.56.56 0 0 1 .165-.397m5.67 5.67a.56.56 0 0 0 .165-.398V5.314a.564.564 0 0 0-.562-.563H1.813a.56.56 0 0 0-.398.165m5.67 5.67-5.67-5.67M8.438 9A.56.56 0 0 0 9 8.438V3.561A.564.564 0 0 0 8.438 3H3.561A.56.56 0 0 0 3 3.563m7.188 3.687a.56.56 0 0 0 .562-.562V1.813a.564.564 0 0 0-.562-.563H5.312a.56.56 0 0 0-.562.563",
+      "vector-effect": "non-scaling-stroke"
+    }, null, -1)
+  ]));
+}
+const s = { render: a };
+export {
+  s as default,
+  a as render
+};

package/dist/node_modules/@knime/components/src/components/DownloadProgressPanel/index.d.ts

@@ -0,0 +1,4 @@
+import { default as DownloadProgressPanel } from './DownloadProgressPanel.vue';
+import { default as DownloadProgressPanelItem } from './DownloadProgressPanelItem.vue';
+import { DownloadItem } from './types';
+export { DownloadProgressPanel, DownloadProgressPanelItem, type DownloadItem };

package/dist/node_modules/@knime/components/src/components/DownloadProgressPanel/types.d.ts

@@ -0,0 +1,7 @@
+export type DownloadItem = {
+    downloadId: string;
+    name: string;
+    status: "IN_PROGRESS" | "CANCELLED" | "READY" | "FAILED";
+    downloadUrl?: string;
+    failureDetails?: string;
+};

package/dist/node_modules/@knime/components/src/components/FileExplorer/composables/useItemDragging.d.ts

@@ -0,0 +1,36 @@
+import { Ref } from 'vue';
+import { UseMultiSelectionReturn } from '../../../composables/multiSelection/useMultiSelection';
+import { FileExplorerItem } from '../types';
+type UseItemDraggingOptions = {
+    items: Ref<Array<FileExplorerItem>>;
+    getItemElement: (index: number) => HTMLElement | null;
+    itemBACK: Ref<HTMLElement | null>;
+    multiSelection: UseMultiSelectionReturn;
+    shouldUseCustomDragPreview: Ref<boolean>;
+    draggingAnimationMode: Ref<"auto" | "manual" | "disabled">;
+    getCustomPreviewEl: () => HTMLElement;
+    isDirectory: (item: FileExplorerItem) => boolean;
+};
+export declare const EMPTY_DRAG_IMAGE: HTMLImageElement | null;
+export declare const useItemDragging: (options: UseItemDraggingOptions) => {
+    isDragging: Ref<boolean, boolean>;
+    onDragStart: (event: DragEvent, index: number) => void;
+    onDragEnter: (event: DragEvent, index: number, isGoBackItem?: boolean) => void;
+    onDragOver: (event: DragEvent) => void;
+    onDrag: (event: DragEvent, item: FileExplorerItem) => {
+        event: DragEvent;
+        item: FileExplorerItem;
+    };
+    onDragLeave: (event: DragEvent, index: number, isGoBackItem?: boolean) => void;
+    onDrop: (event: DragEvent, index: number, isGoBackItem?: boolean) => {
+        sourceItems: Array<string>;
+        targetItem: string;
+        onComplete: (isSuccess: boolean) => void;
+    } | null;
+    onDragEnd: (event: DragEvent, item: FileExplorerItem) => {
+        event: DragEvent;
+        sourceItem: FileExplorerItem;
+        onComplete: (isSuccess: boolean) => void;
+    } | null;
+};
+export {};

package/dist/node_modules/@knime/components/src/components/FileExplorer/composables/useTestUtils.d.ts

@@ -0,0 +1,31 @@
+import { VueWrapper } from '@vue/test-utils';
+type IntersectionObserverMockType = {
+    (callback: (...args: never[]) => unknown): any;
+    __trigger__: (isIntersecting: boolean) => void;
+};
+export declare const MockIntersectionObserver: IntersectionObserverMockType;
+export declare const createSlottedChildComponent: (params: {
+    slottedComponentTemplate: string;
+    slottedComponentData?: unknown;
+}) => {
+    getSlottedChildComponent: (wrapper: VueWrapper<unknown>) => VueWrapper<any, any>;
+    mockComponentInSlot: {
+        name: string;
+        template: string;
+        props: {
+            scope: {
+                type: ObjectConstructor;
+                required: boolean;
+            };
+        };
+        data(): {};
+    };
+    getSlottedStubProp: ({ wrapper, propName, }: {
+        wrapper: VueWrapper<unknown>;
+        propName: string;
+    }) => any;
+    renderSlot: (props: unknown) => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+        [key: string]: any;
+    }>;
+};
+export {};

package/dist/node_modules/@knime/components/src/components/FileExplorer/index.d.ts

@@ -0,0 +1,5 @@
+import { default as FileExplorer } from './components/FileExplorer.vue';
+export * from './composables/useItemDragging';
+export * from './utils/dragGhostHelpers';
+export * from './types';
+export { FileExplorer };

package/dist/node_modules/@knime/components/src/components/FileExplorer/types/index.d.ts

@@ -0,0 +1,32 @@
+import { Component } from 'vue';
+import { MenuItem as BaseMenuItem } from '../../base/MenuItem/MenuItems.vue';
+export type FileExplorerItem<T = Record<string, unknown>> = {
+    id: string;
+    name: string;
+    isOpen: boolean;
+    isDirectory: boolean;
+    isOpenableFile: boolean;
+    canBeRenamed: boolean;
+    canBeDeleted: boolean;
+    meta?: T;
+    disabled?: boolean;
+};
+export type ItemIconRenderer = (item: FileExplorerItem) => Component;
+type DefaultOptions = "rename" | "delete";
+export type Anchor = {
+    item: FileExplorerItem;
+    index: number;
+    element: HTMLElement;
+};
+export type FileExplorerMenuItem = BaseMenuItem & {
+    id: DefaultOptions | Omit<string, DefaultOptions>;
+};
+export type CreateDefaultMenuOption = (item: FileExplorerItem, customProps?: Partial<BaseMenuItem>) => FileExplorerMenuItem;
+export type ItemClickHandler = (menuItem: FileExplorerMenuItem) => void;
+export type ItemClickPayload = {
+    contextMenuItem: FileExplorerMenuItem;
+    anchorItem: FileExplorerItem;
+    isDelete: boolean;
+    isRename: boolean;
+};
+export {};

package/dist/node_modules/@knime/components/src/components/FileExplorer/utils/dragGhostHelpers.d.ts

@@ -0,0 +1,50 @@
+type CreateDragGhostsParams = {
+    /**
+     * The DragStart event that originated the drag
+     */
+    dragStartEvent: DragEvent;
+    /**
+     * Whether to display a badge with a count next to the ghost
+     */
+    badgeCount: number | null;
+    /**
+     * targets that are selected and for whom ghosts will be created
+     */
+    selectedTargets: Array<{
+        /**
+         * Text content to display in each ghost
+         */
+        textContent: string;
+        /**
+         * Element itself
+         */
+        targetEl: HTMLElement;
+    }>;
+};
+type CreateDragGhostsReturnType = {
+    /**
+     * The added ghosts
+     */
+    ghosts: Array<HTMLElement>;
+    /**
+     * A function to remove the ghost when needed. It receives a
+     * parameter to determine whether to animate the removal of the ghosts (true by default)
+     */
+    removeGhosts: (animateOut?: boolean) => void;
+    /**
+     * A function to replace the ghost element when needed.
+     */
+    replaceGhostPreview: (params: {
+        shouldUseCustomPreview: boolean;
+        ghostPreviewEl: HTMLElement;
+        opts?: {
+            leftOffset?: number;
+            topOffset?: number;
+        };
+    }) => void;
+};
+/**
+ * Creates the drag ghosts for the FileExplorer drag operations
+ */
+export declare const createDragGhosts: ({ badgeCount, selectedTargets, }: CreateDragGhostsParams) => CreateDragGhostsReturnType;
+export {};

package/dist/node_modules/@knime/components/src/components/Progress/index.d.ts

@@ -0,0 +1,5 @@
+import { default as ProgressBar } from './ProgressBar/ProgressBar.vue';
+import { default as ProgressItem } from './ProgressItem/ProgressItem.vue';
+import { default as ProgressList } from './ProgressList/ProgressList.vue';
+export * from './types';
+export { ProgressBar, ProgressItem, ProgressList };

package/dist/node_modules/@knime/components/src/components/Progress/types.d.ts

@@ -0,0 +1,14 @@
+import { Component } from 'vue';
+import { PillVariant } from '../Pill/Pill.vue';
+export type ProgressItemProps = {
+    id: string;
+    title: string;
+    subtitle?: string;
+    progress?: number;
+    statusPill?: {
+        text: string;
+        variant: PillVariant;
+        icon?: Component;
+        tooltip?: string;
+    };
+};

package/dist/node_modules/@knime/components/src/components/SvgWithTitle/svgWithTitle.d.ts

@@ -0,0 +1,30 @@
+import { Component } from 'vue';
+/**
+ * Higher order component that decorates a SVG component (loaded with vue-svg-loader) with a `<title>` element
+ * Note that `title` attributes have no effect on `<svg>` elements, so we need to inject a DOM element.
+ *
+ * @example
+ *
+ * import MyIcon from "~/icons/foo.svg";
+ * import svgWithTitle from "…";
+ * export default {
+ *   components: {
+ *       MyIcon: svgWithTitle(MyIcon, "My Title")
+ *   }
+ * };
+ *
+ * or for sfc setup
+ *
+ * import MyIcon from "~/icons/foo.svg";
+ * import svgWithTitle from "…";
+ * const MyIconWithTitle = svgWithTitle(MyIcon, "My Title")
+ *
+ *
+ * @param SvgComponent The component to decorate
+ * @param title The title to insert
+ * @returns The component with a title inserted as the first child of `<svg>`
+ */
+declare const _default: (SvgComponent: Component, title: string) => {
+    render(): any;
+};
+export default _default;

package/dist/node_modules/@knime/components/src/components/Tag/__test__/Tag.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/node_modules/@knime/components/src/components/Tag/__test__/TagList.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/node_modules/@knime/components/src/components/Toast/index.d.ts

@@ -0,0 +1,4 @@
+import { default as ToastStack } from './components/ToastStack.vue';
+export { ToastStack };
+export * from './types';
+export * from './toastService';

package/dist/node_modules/@knime/components/src/components/Toast/toastService.d.ts

@@ -0,0 +1,76 @@
+import { Plugin, Ref } from 'vue';
+import { Toast, ToastService, ToastServiceComposableOptions, ToastWithId, UseToastsOptions } from './types';
+export declare const defaultToastServiceSymbol: unique symbol;
+export declare const defaultGlobalPropertyName = "$toast";
+export declare class ToastServiceError extends Error {
+    constructor(message?: string);
+}
+/**
+ * Each instance of the class is bound to a reactive array of toasts, with which you
+ * can interface via the properties of the `ToastService` object.
+ *
+ * You have the following options to access the toast service:
+ * - `provide` the service object to downstream components by using the `useToastService`
+ *   method in the `setup` of the app's root component;
+ * - register the service object as a global property by getting a Plugin object via
+ *   the `getToastServicePlugin` method, and binding it to the app via `app.use(toastPlugin)`
+ *   in `main.js/ts`;
+ * - get the toast service object directly via `getToastServiceObject` method.
+ */
+export declare class ToastServiceProvider {
+    toasts: Ref<ToastWithId[]>;
+    show: (toast: Toast) => string;
+    remove(id: string): void;
+    removeBy: (predicate: (toast: Toast) => boolean) => void;
+    autoRemove: () => void;
+    removeAll: () => void;
+    readonlyToasts: import('vue').ComputedRef<ToastWithId[]>;
+    toastServiceObject: ToastService;
+    /** Methods for accessing the toast service object */
+    /**
+     * A composable to be used in the app's root component's `setup`. Provides
+     * the service object to downstream components of the app via Vue's dependency
+     * injection, which can then be accessed via the `useToasts` composable.
+     *
+     * @example
+     * toastServiceProvider.useToastService({ serviceSymbol: Symbol("customToastService") });
+     */
+    useToastService: ({ serviceSymbol, }?: ToastServiceComposableOptions) => void;
+    /**
+     * Returns an object that can be used as a plugin with the `app.use()` syntax.
+     * A custom `propertyName` property can be provided to be used as the global
+     * property name instead of the default "$toast".
+     *
+     * @example
+     * const toastPlugin = toastServiceProvider.getToastServicePlugin();
+     * app.use(toastPlugin, {
+     *    propertyName: "$customPropertyName" // "$toast" by default
+     * })
+     */
+    getToastServicePlugin: () => Plugin;
+    /**
+     * Returns the toast service object directly.
+     */
+    getToastServiceObject: () => ToastService;
+}
+/**
+ * Retrieves the toast service object either from the global injection or from the app's
+ * global property via the app instance. If you have multiple instances of the toast
+ * service in the app, you can use different injection key symbols or global property
+ * names to differentiate them.
+ *
+ * @example
+ * import { useToasts } from "@knime/components";
+ *
+ * // Using default options (the app has a shared toast service between components)
+ * const { show } = useToasts();
+ *
+ * // Using a specific symbol (multiple toast services running across the app)
+ * const { show } = useToasts({ serviceSymbol: mySpecialSymbol });
+ *
+ * show({
+ *    type: "success",
+ *    message: "I am an example toast."
+ * });
+ */
+export declare const useToasts: ({ serviceSymbol, propertyName, }?: UseToastsOptions) => ToastService;

package/dist/node_modules/@knime/components/src/components/Toast/types.d.ts

@@ -0,0 +1,111 @@
+import { Component, ComputedRef, VNode } from 'vue';
+type BaseToastButton = {
+    /**
+     * An optional callback function to be executed when the button is clicked.
+     */
+    callback?: () => void;
+    /**
+     * If provided, the button will act as a NuxtLink and navigate to the specified route.
+     * Takes precedence over the `href` prop.
+     */
+    to?: string;
+    /**
+     * If provided, the button will act as a hyperlink directing to the given URL.
+     * Only takes effect if `to` is not provided.
+     */
+    href?: string;
+};
+type ToastButtonWithIcon = {
+    /**
+     * The icon to be displayed alongside with, or instead of the button text.
+     */
+    icon: Component;
+    text?: string;
+};
+type ToastButtonWithText = {
+    icon?: Component;
+    /**
+     * The text content to be displayed on the button.
+     */
+    text: string;
+};
+export type ToastButton = BaseToastButton & (ToastButtonWithIcon | ToastButtonWithText);
+export interface ToastStack {
+    serviceSymbol?: symbol | null;
+    propertyName?: string | null;
+}
+export interface Toast {
+    /**
+     * Set to "info" by default.
+     */
+    type?: "error" | "warning" | "success" | "info";
+    /**
+     * If not specified, the type is used as the headline, e.g. "Info".
+     */
+    headline?: string;
+    message?: string;
+    buttons?: ToastButton[];
+    component?: VNode | null;
+    /**
+     * If set to true, the toast will have an animated progress bar indicating time before
+     * being automatically dismissed.
+     */
+    autoRemove?: boolean;
+    active?: boolean;
+    /**
+     * If set, only one toast with the same key will be in the stack. If a new toast with the same key is added, it will be dropped.
+     */
+    deduplicationKey?: string;
+    meta?: Record<string, unknown>;
+    stackId?: string;
+}
+export interface ToastWithId extends Toast {
+    /**
+     * auto-generated identifier
+     */
+    id: string;
+}
+export interface ToastService {
+    /**
+     * Reactive array of Toast objects.
+     */
+    toasts: ComputedRef<ToastWithId[]>;
+    /**
+     * Adds the provided Toast object to the `toasts` array.
+     * @returns The generated id of the added toast; can be used to call `remove(id)`.
+     */
+    show: (toast: Toast) => string;
+    /**
+     * Removes toast with the given id (returned by `show()`).
+     */
+    remove: (id: string) => void;
+    /**
+     * Removes all Toast objects that match the provided predicate.
+     */
+    removeBy: (predicate: (toast: Toast) => boolean) => void;
+    /**
+     * Removes all Toast objects with `autoRemove` set to `true` from the `toasts` array.
+     */
+    autoRemove: () => void;
+    /**
+     * Removes all Toast objects from the `toasts` array.
+     */
+    removeAll: () => void;
+}
+export interface ToastServiceComposableOptions {
+    /**
+     * The Symbol for the toast service object properties to be bound to.
+     */
+    serviceSymbol?: symbol;
+}
+export interface UseToastsOptions {
+    /**
+     * Custom Symbol to be used as the injection key.
+     */
+    serviceSymbol?: symbol | null;
+    /**
+     * Custom global property name. "$toast" by default.
+     */
+    propertyName?: string | null;
+}
+export {};

package/dist/node_modules/@knime/components/src/components/Toast/useAnimation.d.ts

@@ -0,0 +1,10 @@
+import { Ref } from 'vue';
+export default function useAnimation(targetRef: Ref<HTMLElement | null>, keyframes: Keyframe[], { callback, animationOptions, immediate }?: {
+    callback?: (() => void) | undefined;
+    animationOptions?: {} | undefined;
+    immediate?: boolean | undefined;
+}): {
+    play: () => void;
+    pause: () => void;
+    reset: () => void;
+};

package/dist/node_modules/@knime/components/src/components/UploadProgressPanel/index.d.ts

@@ -0,0 +1,5 @@
+import { default as UploadProgressPanel } from './UploadProgressPanel.vue';
+import { default as UploadProgressPanelItem } from './UploadProgressPanelItem.vue';
+import { useUploadManager } from './useUploadManager';
+export { UploadProgressPanel, UploadProgressPanelItem, useUploadManager };
+export * from './types';

package/dist/node_modules/@knime/components/src/components/UploadProgressPanel/types.d.ts

@@ -0,0 +1,10 @@
+import { UploadStateName } from '@knime/utils';
+export type UploadItemStatus = Exclude<UploadStateName, "idle"> | "processing";
+export type UploadItem = {
+    id: string;
+    name: string;
+    size: number;
+    progress?: number;
+    status?: UploadItemStatus;
+    failureDetails?: string;
+};