@knime/scripting-editor 0.0.81 → 0.0.82

package/dist/node_modules/@knime/components/src/components/forms/Twinlist/Twinlist.vue.d.ts

@@ -0,0 +1,381 @@
+import { PropType, Ref } from 'vue';
+import { Id, PossibleValue } from '../possibleValues';
+
+interface TransformOnMovePayload {
+    /**
+     * The to be updated list of ids
+     */
+    previous: Id[];
+    movingParts: {
+        /**
+         * The moved items that are not the "unknown values"
+         */
+        knownValues: Array<Id>;
+        /**
+         * Whether the unknown values are part of the moved items
+         */
+        movingUnknownValues: boolean;
+    };
+}
+/** The included values or null if not yet known. Values which are not an id in the possible values will be shown as missing. */
+type SimpleTwinlistModelValue<T extends Id> = null | T[];
+/**
+ * using this form of model value allows showing unknown values. With that the logic for missing values also changes:
+ * Missing values on the same side as unknown values are not displayed and removed as soon as the user moves items.
+ * Also missing values now can always exist on the opposite side of the unknown values which is why we also need to
+ *  keep track of the excluded values as data.
+ */
+interface TwinlistModelValueWithUnknownValues<T extends Id> {
+    /**
+     * null if not yet known
+     */
+    includedValues: T[] | null;
+    /**
+     * null if not yet known
+     */
+    excludedValues: T[] | null;
+    includeUnknownValues: boolean;
+}
+type TwinlistModelValue<T extends Id = Id> = SimpleTwinlistModelValue<T> | TwinlistModelValueWithUnknownValues<T>;
+declare const useTwinlistModelValue: (modelValue: Ref<TwinlistModelValue>) => {
+    includedValues: import('vue').ComputedRef<Id[] | null>;
+    excludedValues: import('vue').ComputedRef<Id[] | null>;
+    showUnknownExcludedValues: import('vue').ComputedRef<boolean>;
+    showUnknownIncludedValues: import('vue').ComputedRef<boolean>;
+    getEmitValue: (newIncludedValues: Id[] | null, toNewExcluded?: (oldVal: Id[] | null) => Id[] | null, toNewIncludeUnknownValues?: (oldVal: boolean) => boolean) => TwinlistModelValue;
+};
+export { type TwinlistModelValue, useTwinlistModelValue };
+declare const _default: import('vue').DefineComponent<{
+    modelValue: {
+        type: PropType<TwinlistModelValue<Id>>;
+        default: null;
+    };
+    initialCaseSensitiveSearch: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    initialSearchTerm: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    /**
+     * Hiding and disabling
+     */
+    showSearch: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    disabled: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    showEmptyState: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    /**
+     * Labels
+     */
+    leftLabel: {
+        type: StringConstructor;
+        required: true;
+        default: string;
+    };
+    rightLabel: {
+        type: StringConstructor;
+        required: true;
+        default: string;
+    };
+    withSearchLabel: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    searchLabel: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    searchPlaceholder: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    unknownValuesText: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    /**
+     * Is only used when emptyStateComponent is null
+     */
+    emptyStateLabel: {
+        default: string;
+        type: StringConstructor;
+    };
+    /**
+     * this component is displayed centered in the middle of the box in case it is empty
+     */
+    emptyStateComponent: {
+        default: null;
+        type: ObjectConstructor;
+    };
+    /**
+     * Controls the size of the list.
+     * Number of visible items (for others user need to scroll)
+     * - 0 means all
+     * - values 1 - 4  are ignored; 5 is minimum
+     */
+    size: {
+        type: NumberConstructor;
+        default: number;
+        validator(value: number): boolean;
+    };
+    isValid: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    /**
+     * List of possible values. Each item must have an `id` and a `text` property
+     * @example
+     * [{
+     *   id: 'pdf',
+     *   text: 'PDF'
+     * }, {
+     *   id: 'XLS',
+     *   text: 'Excel',
+     * }]
+     */
+    possibleValues: {
+        type: PropType<PossibleValue[]>;
+        default: () => never[];
+    };
+    /**
+     * If this setting is true, on a change of possible values, the currently
+     * chosen values which are missing with respect to the new possible values
+     * are removed.
+     */
+    filterChosenValuesOnPossibleValuesChange: {
+        type: BooleanConstructor;
+        default: boolean;
+        required: false;
+    };
+    compact: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    includedValues: import('vue').ComputedRef<Id[] | null>;
+    excludedValues: import('vue').ComputedRef<Id[] | null>;
+    showUnknownExcludedValues: import('vue').ComputedRef<boolean>;
+    showUnknownIncludedValues: import('vue').ComputedRef<boolean>;
+    getEmitValue: (newIncludedValues: Id[] | null, toNewExcluded?: (oldVal: Id[] | null) => Id[] | null, toNewIncludeUnknownValues?: (oldVal: boolean) => boolean) => TwinlistModelValue<Id>;
+    searchTerm: Ref<string>;
+    filteredExcludedItems: import('vue').ComputedRef<PossibleValue[]>;
+    filteredIncludedItems: import('vue').ComputedRef<PossibleValue[]>;
+    knownExcludedValues: import('vue').ComputedRef<Id[]>;
+    knownIncludedValues: import('vue').ComputedRef<Id[] | null>;
+    possibleValueIds: import('vue').ComputedRef<Id[]>;
+    possibleValueIdsSet: import('vue').ComputedRef<Set<Id>>;
+    excludedLabels: import('vue').ComputedRef<string | null>;
+    includedLabels: import('vue').ComputedRef<string | null>;
+    caseSensitiveSearch: Ref<boolean>;
+    allIncludedItems: import('vue').ComputedRef<PossibleValue[]>;
+    possibleValueMap: import('vue').ComputedRef<Record<Id, {
+        item: PossibleValue;
+        index: number;
+    }>>;
+}, {
+    invalidPossibleValueIds: Set<unknown>;
+    rightSelected: Id[];
+    leftSelected: Id[];
+    unknownValuesId: symbol;
+}, {
+    listSize(): number;
+    moveAllRightButtonDisabled(): boolean;
+    moveRightButtonDisabled(): boolean;
+    moveAllLeftButtonDisabled(): boolean;
+    moveLeftButtonDisabled(): boolean;
+}, {
+    getIndex(id: Id): number;
+    compareByOriginalSorting(a: Id, b: Id): number;
+    clearSelections(): void;
+    moveItems(items: Id[], { toNewIncludedValues, toNewExcludedValues, }: {
+        toNewIncludedValues: (params: TransformOnMovePayload) => Id[];
+        toNewExcludedValues: (params: TransformOnMovePayload) => Id[];
+    }): void;
+    moveRight(itemsParam?: Id[] | null): void;
+    moveLeft(itemsParam?: Id[] | null): void;
+    /**
+     * Filters out the moved items and also invalid items if unknown values are being moved.
+     */
+    filterMovedItems({ previous, movingParts: { movingUnknownValues, knownValues }, }: TransformOnMovePayload): Id[];
+    /**
+     * Adds the given items sorting by the order in the possible values afterwards and removing invalid items
+     * if unknown values are being moved
+     */
+    addMovedItems({ previous, movingParts: { movingUnknownValues, knownValues }, }: TransformOnMovePayload): Id[];
+    onMoveRightButtonClick(): void;
+    onMoveAllRightButtonClick(): void;
+    onMoveAllRightButtonKey(e: KeyboardEvent): void;
+    onMoveRightButtonKey(e: KeyboardEvent): void;
+    onMoveLeftButtonClick(): void;
+    onMoveAllLeftButtonClick(): void;
+    onMoveLeftButtonKey(e: KeyboardEvent): void;
+    onMoveAllLeftButtonKey(e: KeyboardEvent): void;
+    stopPropagation(e: KeyboardEvent): void;
+    onLeftListBoxDoubleClick(item: Id): void;
+    onLeftListBoxShiftDoubleClick(items: Id[]): void;
+    onRightListBoxDoubleClick(item: Id): void;
+    onRightListBoxShiftDoubleClick(items: Id[]): void;
+    onLeftInput(value: Id[]): void;
+    onRightInput(value: Id[]): void;
+    onSearchInput(value: string): void;
+    hasSelection(): boolean;
+    validate(): {
+        isValid: boolean;
+        errorMessage: string | null;
+    };
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    modelValue: {
+        type: PropType<TwinlistModelValue<Id>>;
+        default: null;
+    };
+    initialCaseSensitiveSearch: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    initialSearchTerm: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    /**
+     * Hiding and disabling
+     */
+    showSearch: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    disabled: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    showEmptyState: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    /**
+     * Labels
+     */
+    leftLabel: {
+        type: StringConstructor;
+        required: true;
+        default: string;
+    };
+    rightLabel: {
+        type: StringConstructor;
+        required: true;
+        default: string;
+    };
+    withSearchLabel: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    searchLabel: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    searchPlaceholder: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    unknownValuesText: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    /**
+     * Is only used when emptyStateComponent is null
+     */
+    emptyStateLabel: {
+        default: string;
+        type: StringConstructor;
+    };
+    /**
+     * this component is displayed centered in the middle of the box in case it is empty
+     */
+    emptyStateComponent: {
+        default: null;
+        type: ObjectConstructor;
+    };
+    /**
+     * Controls the size of the list.
+     * Number of visible items (for others user need to scroll)
+     * - 0 means all
+     * - values 1 - 4  are ignored; 5 is minimum
+     */
+    size: {
+        type: NumberConstructor;
+        default: number;
+        validator(value: number): boolean;
+    };
+    isValid: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    /**
+     * List of possible values. Each item must have an `id` and a `text` property
+     * @example
+     * [{
+     *   id: 'pdf',
+     *   text: 'PDF'
+     * }, {
+     *   id: 'XLS',
+     *   text: 'Excel',
+     * }]
+     */
+    possibleValues: {
+        type: PropType<PossibleValue[]>;
+        default: () => never[];
+    };
+    /**
+     * If this setting is true, on a change of possible values, the currently
+     * chosen values which are missing with respect to the new possible values
+     * are removed.
+     */
+    filterChosenValuesOnPossibleValuesChange: {
+        type: BooleanConstructor;
+        default: boolean;
+        required: false;
+    };
+    compact: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}, {
+    size: number;
+    disabled: boolean;
+    compact: boolean;
+    possibleValues: PossibleValue[];
+    modelValue: TwinlistModelValue<Id>;
+    isValid: boolean;
+    emptyStateLabel: string;
+    emptyStateComponent: Record<string, any>;
+    showEmptyState: boolean;
+    initialCaseSensitiveSearch: boolean;
+    initialSearchTerm: string;
+    showSearch: boolean;
+    leftLabel: string;
+    rightLabel: string;
+    withSearchLabel: boolean;
+    searchLabel: string;
+    searchPlaceholder: string;
+    unknownValuesText: string;
+    filterChosenValuesOnPossibleValuesChange: boolean;
+}, {}>;
+export default _default;

package/dist/node_modules/@knime/components/src/components/forms/ValueSwitch/ValueSwitch.vue.d.ts

@@ -0,0 +1,65 @@
+import { PropType } from 'vue';
+import { BaseRadioButtonItem } from '../RadioButtons/BaseRadioButtons.vue';
+
+export type ValueSwitchItem = BaseRadioButtonItem;
+declare const _default: import('vue').DefineComponent<{
+    id: {
+        type: StringConstructor;
+        default: null;
+    };
+    modelValue: {
+        type: StringConstructor;
+        default: null;
+    };
+    name: {
+        type: StringConstructor;
+        default: null;
+    };
+    disabled: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    possibleValues: {
+        type: PropType<BaseRadioButtonItem[]>;
+        default: () => never[];
+    };
+    compact: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, unknown, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    id: {
+        type: StringConstructor;
+        default: null;
+    };
+    modelValue: {
+        type: StringConstructor;
+        default: null;
+    };
+    name: {
+        type: StringConstructor;
+        default: null;
+    };
+    disabled: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    possibleValues: {
+        type: PropType<BaseRadioButtonItem[]>;
+        default: () => never[];
+    };
+    compact: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}, {
+    disabled: boolean;
+    id: string;
+    name: string;
+    compact: boolean;
+    possibleValues: BaseRadioButtonItem[];
+    modelValue: string;
+}, {}>;
+export default _default;

package/dist/node_modules/@knime/ui-extension-renderer/src/UIExtIFrame.vue.d.ts

@@ -0,0 +1,27 @@
+import { UIExtensionPushEvents, UIExtensionServiceAPILayer } from '@knime/ui-extension-service';
+
+declare const _default: import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<{
+    resourceLocation: string;
+    apiLayer: UIExtensionServiceAPILayer;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    serviceCreated: (service: {
+        dispatchPushEvent: (event: UIExtensionPushEvents.PushEvent<any, any>) => void;
+    }) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    resourceLocation: string;
+    apiLayer: UIExtensionServiceAPILayer;
+}>>> & {
+    onServiceCreated?: ((service: {
+        dispatchPushEvent: (event: UIExtensionPushEvents.PushEvent<any, any>) => void;
+    }) => any) | undefined;
+}, {}, {}>;
+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/node_modules/@knime/ui-extension-renderer/src/UIExtShadowApp.vue.d.ts

@@ -0,0 +1,41 @@
+import { UIExtensionServiceAPILayer, UIExtensionPushEvents } from '@knime/ui-extension-service';
+import { StyleValue } from 'vue';
+
+interface Props {
+    resourceLocation: string;
+    apiLayer: UIExtensionServiceAPILayer;
+    style?: StyleValue;
+}
+declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    style: null;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    serviceCreated: (_service: {
+        dispatchPushEvent: (event: UIExtensionPushEvents.PushEvent<any, any>) => void;
+    }) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    style: null;
+}>>> & {
+    onServiceCreated?: ((_service: {
+        dispatchPushEvent: (event: UIExtensionPushEvents.PushEvent<any, any>) => void;
+    }) => any) | undefined;
+}, {
+    style: string | false | import('vue').CSSProperties | StyleValue[] | null;
+}, {}>;
+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/node_modules/@knime/ui-extension-renderer/src/UIExtension.vue.d.ts

@@ -0,0 +1,49 @@
+import { StyleValue } from 'vue';
+import { UIExtensionAPILayer } from './types/UIExtensionAPILayer';
+import { ExtensionConfig } from './types/ExtensionConfig';
+
+/**
+ * Wrapper for all UIExtensions. Determines the type of component to render (either native/Vue-based or iframe-based).
+ * Also detects changes to it's configuration and increments a local counter to help with re-renders of iframe-based
+ * components.
+ */
+type Props = {
+    apiLayer: UIExtensionAPILayer;
+    extensionConfig: ExtensionConfig;
+    resourceLocation: string;
+    /**
+     * See ExtensionConfig.initialSharedData
+     */
+    initialSharedData?: any;
+    isReporting?: boolean;
+    isDialogLayout?: boolean;
+    shadowAppStyle?: StyleValue | null;
+};
+declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    initialSharedData: null;
+    shadowAppStyle: null;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    initialSharedData: null;
+    shadowAppStyle: null;
+}>>>, {
+    initialSharedData: any;
+    shadowAppStyle: string | false | import('vue').CSSProperties | StyleValue[] | null;
+}, {}>;
+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/node_modules/@knime/ui-extension-renderer/src/UIExtensionAlerts.vue.d.ts

@@ -0,0 +1,34 @@
+import { Alert } from '@knime/ui-extension-service';
+
+type Props = {
+    alert?: Alert | null;
+};
+declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    alert: null;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    display: () => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    alert: null;
+}>>> & {
+    onDisplay?: (() => any) | undefined;
+}, {
+    alert: Alert | null;
+}, {}>;
+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/node_modules/@knime/ui-extension-renderer/src/UIExtensionErrorOverlay.vue.d.ts

@@ -0,0 +1,41 @@
+import { Alert } from '@knime/ui-extension-service';
+
+/**
+ * This is the local alert/error management component created for use with the NodeViewIFrame. Its main use is to
+ * replace the native browser `alert`. It is composed of a full screen overlay which blocks mouse events and an
+ * icon with a tooltip to show more details. When active, this component uses a @see Popover to cover 100% of the
+ * parent container. If parent container lacks dimensions, you must assign a min-width/height conditionally when
+ * this component is active for proper display.
+ */
+type Props = {
+    alert?: Alert | null;
+};
+declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    alert: null;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    display: () => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    alert: null;
+}>>> & {
+    onDisplay?: (() => any) | undefined;
+}, {
+    alert: Alert | null;
+}, {}>;
+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/node_modules/@knime/ui-extension-renderer/src/UIExtensionWarningButton.vue.d.ts

@@ -0,0 +1,34 @@
+import { Alert } from '@knime/ui-extension-service';
+
+type Props = {
+    alert?: Alert | null;
+};
+declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    alert: null;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    display: () => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    alert: null;
+}>>> & {
+    onDisplay?: (() => any) | undefined;
+}, {
+    alert: Alert | null;
+}, {}>;
+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/src/initial-data-service-browser-mock.d.ts

@@ -1,7 +1,8 @@
-import { GenericInitialData, InitialDataServiceType } from './initial-data-service';
+import { GenericInitialData, InitialDataServiceType, InputConnectionInfo } from './initial-data-service';
 import { InputOutputModel } from 'lib/main';
 
 export declare const DEFAULT_INPUT_OBJECTS: InputOutputModel[];
+export declare const DEFAULT_PORT_INFORMATION: InputConnectionInfo[];
 export declare const DEFAULT_OUTPUT_OBJECTS: InputOutputModel[];
 export declare const DEFAULT_FLOW_VARIABLE_INPUTS: InputOutputModel;
 export declare const DEFAULT_INITIAL_DATA: GenericInitialData;