@knime/scripting-editor 0.0.46 → 0.0.48

package/dist/scripting-service-browser-mock.d.ts

@@ -0,0 +1 @@
+export * from './src/scripting-service-browser-mock'

package/dist/scripting-service-browser-mock.js

@@ -0,0 +1,111 @@
+function l(e) {
+  return new Promise((n) => setTimeout(n, e));
+}
+const c = 100, a = 2e3, r = (e, ...n) => {
+  typeof consola > "u" ? console.log(e, ...n) : consola.log(e, ...n);
+}, u = (e, ...n) => {
+  typeof consola > "u" ? console.error(e, ...n) : consola.error(e, ...n);
+}, i = (e) => (...n) => (r(`Called scriptingService.${e}`, ...n), Promise.resolve()), g = [
+  {
+    name: "Input Table 1",
+    subItems: [
+      {
+        name: "Column 1",
+        type: "Number"
+      },
+      {
+        name: "Column 2",
+        type: "String"
+      },
+      {
+        name: "Column 3",
+        type: "String"
+      }
+    ]
+  }
+], S = [
+  {
+    name: "Output Table 1"
+  }
+], d = {
+  name: "Flow Variables",
+  subItems: [
+    {
+      name: "flowVar1",
+      type: "Number"
+    },
+    {
+      name: "flowVar2",
+      type: "String"
+    },
+    {
+      name: "flowVar3",
+      type: "String"
+    }
+  ]
+}, v = (e) => {
+  const n = /* @__PURE__ */ new Map(), o = {
+    getHubId: () => Promise.resolve("My Mocked KNIME Hub"),
+    isLoggedIn: () => Promise.resolve(!0),
+    suggestCode: async () => {
+      await l(a);
+      const s = n.get("codeSuggestion");
+      return typeof s < "u" && s({
+        status: "SUCCESS",
+        code: JSON.stringify({ code: "// THIS IS A FAKE AI SUGGESTION" })
+      }), {};
+    },
+    abortSuggestCodeRequest: () => Promise.resolve()
+  };
+  return {
+    async sendToService(s, t) {
+      return r(`Called scriptingService.sendToService("${s}")`, t), await l(c), e.sendToServiceMockResponses && s in e.sendToServiceMockResponses ? e.sendToServiceMockResponses[s](t) : s in o ? o[s](t) : (u(
+        `${s} not implemented in sendToServiceMockResponses.
+      Returning undefined.`
+      ), Promise.resolve());
+    },
+    // Settings and dialog window
+    getInitialSettings() {
+      return r("Called scriptingService.getInitialSettings"), Promise.resolve(e.initialSettings ?? { script: "Hello world" });
+    },
+    saveSettings: i("saveSettings"),
+    closeDialog: i("closeDialog"),
+    // Input and output objects
+    inputsAvailable() {
+      return r("Called scriptingService.inputsAvailable"), Promise.resolve(e.inputsAvailable ?? !0);
+    },
+    getInputObjects() {
+      return r("Called scriptingService.getInputObjects"), Promise.resolve(e.inputObjects ?? g);
+    },
+    getOutputObjects() {
+      return r("Called scriptingService.getOutputObjects"), Promise.resolve(e.outputObjects ?? S);
+    },
+    getFlowVariableInputs() {
+      return r("Called scriptingService.getFlowVariableInputs"), Promise.resolve(
+        e.flowVariableInputs ?? d
+      );
+    },
+    // Code assistant
+    isCodeAssistantInstalled() {
+      return r("Called scriptingService.isCodeAssistantInstalled"), Promise.resolve(!0);
+    },
+    isCodeAssistantEnabled() {
+      return r("Called scriptingService.isCodeAssistantEnabled"), Promise.resolve(!0);
+    },
+    // Event handler
+    registerEventHandler(s, t) {
+      r("Called scriptingService.registerEventHandler", s), n.set(s, t);
+    },
+    // Language server
+    connectToLanguageServer: i("connectToLanguageServer"),
+    configureLanguageServer: i("configureLanguageServer"),
+    // Console handling
+    eventHandlers: n
+  };
+};
+export {
+  d as DEFAULT_FLOW_VARIABLE_INPUTS,
+  g as DEFAULT_INPUT_OBJECTS,
+  S as DEFAULT_OUTPUT_OBJECTS,
+  v as createScriptingServiceMock
+};

package/dist/scripting-service-instance.d.ts

@@ -0,0 +1 @@
+export * from './src/scripting-service-instance'

package/dist/scripting-service-instance.js

@@ -0,0 +1,8 @@
+let e;
+const c = (t) => {
+  e = t;
+}, i = () => e;
+export {
+  i as getScriptingServiceInstance,
+  c as setScriptingServiceInstance
+};

package/dist/src/components/CompactTabBar.vue.d.ts

@@ -15,7 +15,9 @@ declare const _default: import("vue").DefineComponent<{
         type: ArrayConstructor;
         default: () => never[];
     };
-}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (...args: any[]) => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
     disabled: {
         type: BooleanConstructor;
         default: boolean;

package/dist/src/components/InputOutputItem.vue.d.ts

@@ -23,15 +23,18 @@ export type InputOutputModel = {
     }[];
 };
 export declare const INPUT_OUTPUT_DRAG_EVENT_ID = "input_output_drag_event";
-declare const _default: import("vue").DefineComponent<{
-    inputOutputItem: {
-        type: import("vue").PropType<InputOutputModel>;
-        required: true;
-    };
-}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
-    inputOutputItem: {
-        type: import("vue").PropType<InputOutputModel>;
+declare const _default: import("vue").DefineComponent<__VLS_TypePropsToRuntimeProps<{
+    inputOutputItem: InputOutputModel;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    inputOutputItem: InputOutputModel;
+}>>>, {}, {}>;
+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;
     };
-}>>, {}, {}>;
-export default _default;
+};

package/dist/src/components/InputOutputPane.vue.d.ts

@@ -1,6 +1,6 @@
 declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "drop-event-handler-created": (dropEventHandler: Function) => void;
+    "drop-event-handler-created": (dropEventHandler: (payload: DragEvent) => void) => void;
 }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>> & {
-    "onDrop-event-handler-created"?: ((dropEventHandler: Function) => any) | undefined;
+    "onDrop-event-handler-created"?: ((dropEventHandler: (payload: DragEvent) => void) => any) | undefined;
 }, {}, {}>;
 export default _default;

package/dist/src/components/OutputConsole.vue.d.ts

@@ -6,11 +6,15 @@ export type ConsoleText = XOR<{
 }, {
     error: string;
 }>;
-export type ConsoleHandler = (text: ConsoleText) => void;
+export type ConsoleHandler = {
+    writeln: (text: ConsoleText) => void;
+    write: (text: ConsoleText) => void;
+    clear: () => void;
+};
 declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "console-created": (handler: ConsoleHandler, clearConsoleCallback: () => void) => void;
+    "console-created": (handler: ConsoleHandler) => void;
 }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>> & {
-    "onConsole-created"?: ((handler: ConsoleHandler, clearConsoleCallback: () => void) => any) | undefined;
+    "onConsole-created"?: ((handler: ConsoleHandler) => any) | undefined;
 }, {}, {}>, {
     "console-status"?(_: {}): any;
 }>;

package/dist/src/components/ScriptingEditor.vue.d.ts

@@ -1,142 +1,72 @@
-import { type PropType } from "vue";
-import { type SettingsMenuItem } from "./SettingsPage.vue";
 import type { MenuItem } from "webapps-common/ui/components/MenuItems.vue";
-import type { editor } from "monaco-editor";
-import type { ConsoleHandler } from "./OutputConsole.vue";
 export type PaneSizes = {
     [key in "left" | "right" | "bottom"]: number;
 };
-declare const _default: import("vue").DefineComponent<{
-    title: {
-        type: StringConstructor;
-        default: null;
-    };
-    language: {
-        type: StringConstructor;
-        default: null;
-    };
-    fileName: {
-        type: StringConstructor;
-        default: null;
-    };
-    rightPaneLayout: {
-        type: PropType<"fixed" | "relative">;
-        default: string;
-    };
-    menuItems: {
-        type: {
-            (arrayLength: number): MenuItem[];
-            (...items: MenuItem[]): MenuItem[];
-            new (arrayLength: number): MenuItem[];
-            new (...items: MenuItem[]): MenuItem[];
-            isArray(arg: any): arg is any[];
-            readonly prototype: any[];
-            from<T>(arrayLike: ArrayLike<T>): T[];
-            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
-            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
-            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
-            of<T_4>(...items: T_4[]): T_4[];
-            readonly [Symbol.species]: ArrayConstructor;
-        };
-        default: never[];
-    };
-    showControlBar: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    initialPaneSizes: {
-        type: PropType<PaneSizes>;
-        default: PaneSizes;
-    };
-}, unknown, {
-    currentPaneSizes: PaneSizes;
-    previousPaneSizes: PaneSizes;
-    commonMenuItems: MenuItem[];
-    editorModel: editor.ITextModel | null;
-    showSettingsPage: boolean;
-    bottomPaneOptions: {
-        value: string;
-        label: string;
-    }[];
-    bottomPaneActiveTab: import("vue").Ref<string>;
-    dropEventHandler: Function | null;
-}, {
-    usedMainPaneSize(): number;
-    usedHorizontalCodeEditorPaneSize(): number;
-    usedVerticalCodeEditorPaneSize(): number;
-    isLeftPaneCollapsed(): boolean;
-    isRightPaneCollapsed(): boolean;
-    isBottomPaneCollapsed(): boolean;
-}, {
-    collapsePane(pane: keyof PaneSizes): void;
-    resizePane(size: number, pane: keyof PaneSizes, updatePreviousPaneSize?: boolean): void;
-    updatePreviousPaneSize(pane: keyof PaneSizes): void;
-    updateRightPane(size: number): void;
-    onMonacoCreated({ editor, editorModel, }: {
-        editor: editor.IStandaloneCodeEditor;
-        editorModel: editor.ITextModel;
-    }): void;
-    saveSettings(): void;
-    closeDialog(): void;
-    onMenuItemClicked(args: {
-        event: Event;
-        item: SettingsMenuItem;
-    }): void;
-    onDropEventHandlerCreated(dropEventHandler: Function): void;
-    onConsoleCreated(handler: ConsoleHandler, clearConsoleCallback: () => void): void;
-}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("monaco-created" | "menu-item-clicked" | "save-settings")[], "monaco-created" | "menu-item-clicked" | "save-settings", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
-    title: {
-        type: StringConstructor;
-        default: null;
-    };
-    language: {
-        type: StringConstructor;
-        default: null;
-    };
-    fileName: {
-        type: StringConstructor;
-        default: null;
-    };
-    rightPaneLayout: {
-        type: PropType<"fixed" | "relative">;
-        default: string;
-    };
-    menuItems: {
-        type: {
-            (arrayLength: number): MenuItem[];
-            (...items: MenuItem[]): MenuItem[];
-            new (arrayLength: number): MenuItem[];
-            new (...items: MenuItem[]): MenuItem[];
-            isArray(arg: any): arg is any[];
-            readonly prototype: any[];
-            from<T>(arrayLike: ArrayLike<T>): T[];
-            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
-            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
-            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
-            of<T_4>(...items: T_4[]): T_4[];
-            readonly [Symbol.species]: ArrayConstructor;
-        };
-        default: never[];
-    };
-    showControlBar: {
-        type: BooleanConstructor;
-        default: boolean;
+interface Props {
+    title: string;
+    language: string;
+    fileName: string;
+    rightPaneLayout?: "fixed" | "relative";
+    menuItems?: MenuItem[];
+    showControlBar?: boolean;
+    initialPaneSizes?: PaneSizes;
+}
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    rightPaneLayout: string;
+    menuItems: () => never[];
+    showControlBar: boolean;
+    initialPaneSizes: () => {
+        left: number;
+        right: number;
+        bottom: number;
     };
-    initialPaneSizes: {
-        type: PropType<PaneSizes>;
-        default: PaneSizes;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "menu-item-clicked": (...args: any[]) => void;
+    "save-settings": (...args: any[]) => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    rightPaneLayout: string;
+    menuItems: () => never[];
+    showControlBar: boolean;
+    initialPaneSizes: () => {
+        left: number;
+        right: number;
+        bottom: number;
     };
-}>> & {
-    "onMonaco-created"?: ((...args: any[]) => any) | undefined;
+}>>> & {
     "onMenu-item-clicked"?: ((...args: any[]) => any) | undefined;
     "onSave-settings"?: ((...args: any[]) => any) | undefined;
 }, {
-    title: string;
-    language: string;
-    fileName: string;
     menuItems: MenuItem[];
     rightPaneLayout: "fixed" | "relative";
     showControlBar: boolean;
     initialPaneSizes: PaneSizes;
-}, {}>;
+}, {}>, {
+    "settings-title"?(_: {}): any;
+    "settings-content"?(_: {}): any;
+    "code-editor-controls"?(_: {}): any;
+    "right-pane"?(_: {}): any;
+    "console-status"?(_: {}): any;
+}>;
 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];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/src/components/{AiBar.vue.d.ts → ai-assistant/AiBar.vue.d.ts}

@@ -1,5 +1,5 @@
 import { type PropType } from "vue";
-import type { PaneSizes } from "./ScriptingEditor.vue";
+import type { PaneSizes } from "../ScriptingEditor.vue";
 declare const _default: import("vue").DefineComponent<{
     currentPaneSizes: {
         type: PropType<PaneSizes>;
@@ -14,7 +14,7 @@ declare const _default: import("vue").DefineComponent<{
         default: null;
     };
 }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "accept-suggestion": (value: boolean) => void;
+    "accept-suggestion": () => void;
     "close-ai-bar": () => void;
 }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
     currentPaneSizes: {
@@ -30,7 +30,7 @@ declare const _default: import("vue").DefineComponent<{
         default: null;
     };
 }>> & {
-    "onAccept-suggestion"?: ((value: boolean) => any) | undefined;
+    "onAccept-suggestion"?: (() => any) | undefined;
     "onClose-ai-bar"?: (() => any) | undefined;
 }, {
     language: string;

package/dist/src/components/ai-assistant/AiSuggestion.vue.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "accept-suggestion": (acceptedCode: string) => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>> & {
+    "onAccept-suggestion"?: ((acceptedCode: string) => any) | undefined;
+}, {}, {}>;
+export default _default;

package/dist/src/consoleHandler.d.ts

@@ -0,0 +1,3 @@
+import type { ConsoleHandler } from './components/OutputConsole.vue';
+export declare let consoleHandler: ConsoleHandler;
+export declare const setConsoleHandler: (handler: ConsoleHandler) => void;

package/dist/src/editor.d.ts

@@ -0,0 +1,63 @@
+import * as monaco from "monaco-editor";
+import { type Ref } from "vue";
+type ContainerParams = {
+    /** The HTML element to mount the editor to. */
+    container: Ref<HTMLDivElement | undefined>;
+};
+export type UseCodeEditorParams = ContainerParams & ({
+    language: string;
+    fileName: string;
+} | {
+    editorModel: monaco.editor.ITextModel;
+});
+export type UseCodeEditorReturn = {
+    editorModel: monaco.editor.ITextModel;
+    editor: Ref<monaco.editor.IStandaloneCodeEditor | undefined>;
+    /**
+     * The current text in the editor. Allows updating the full text. The user
+     * will be able to undo the change.
+     */
+    text: Ref<string>;
+    /**
+     * The current selection in the editor.
+     */
+    selection: Readonly<Ref<string>>;
+    /**
+     * All currently selected lines in the editor from first to last column.
+     * Also includes partly selected lines.
+     */
+    selectedLines: Readonly<Ref<string>>;
+    /**
+     * Set the initial text of the editor. The user won't be able to undo this.
+     * @param text the text to set
+     */
+    setInitialText: (text: string) => void;
+};
+export type UseDiffEditorParams = ContainerParams & {
+    originalModel: monaco.editor.ITextModel;
+    modifiedFileName: string;
+};
+export type UseDiffEditorReturn = {
+    editorModel: monaco.editor.IDiffEditorModel;
+    editor: Ref<monaco.editor.IStandaloneDiffEditor | undefined>;
+    /**
+     * The current modified text. Allows updating the full text. The user
+     * will be able to undo the change.
+     */
+    modifiedText: Ref<string>;
+    /**
+     * Set the initial modified text of the editor. The user won't be able to undo this.
+     * @param text the text to set
+     */
+    setInitialModifiedText: (modifiedText: string) => void;
+};
+export declare const useCodeEditor: (params: UseCodeEditorParams) => UseCodeEditorReturn;
+export declare const useDiffEditor: (params: UseDiffEditorParams) => UseDiffEditorReturn;
+export declare const useMainCodeEditorStore: () => import("vue").ShallowRef<UseCodeEditorReturn | undefined>;
+export declare const useMainCodeEditor: (params: UseCodeEditorParams) => UseCodeEditorReturn;
+declare const _default: {
+    useCodeEditor: (params: UseCodeEditorParams) => UseCodeEditorReturn;
+    useDiffEditor: (params: UseDiffEditorParams) => UseDiffEditorReturn;
+    useMainCodeEditorStore: () => import("vue").ShallowRef<UseCodeEditorReturn | undefined>;
+};
+export default _default;

package/dist/src/scripting-service-browser-mock.d.ts

@@ -0,0 +1,30 @@
+import type { InputOutputModel } from "./components/InputOutputItem.vue";
+import type { NodeSettings, ScriptingServiceType } from "./scripting-service";
+export declare const DEFAULT_INPUT_OBJECTS: {
+    name: string;
+    subItems: {
+        name: string;
+        type: string;
+    }[];
+}[];
+export declare const DEFAULT_OUTPUT_OBJECTS: {
+    name: string;
+}[];
+export declare const DEFAULT_FLOW_VARIABLE_INPUTS: {
+    name: string;
+    subItems: {
+        name: string;
+        type: string;
+    }[];
+};
+export type ScriptingServiceMockOptions = {
+    sendToServiceMockResponses?: Record<string, (options?: any[]) => Promise<any>>;
+    initialSettings?: NodeSettings;
+    inputsAvailable?: boolean;
+    inputObjects?: InputOutputModel[];
+    outputObjects?: InputOutputModel[];
+    flowVariableInputs?: InputOutputModel;
+};
+export declare const createScriptingServiceMock: (opt: ScriptingServiceMockOptions) => ScriptingServiceType & {
+    eventHandlers: Map<string, (args: any) => void>;
+};

package/dist/src/scripting-service-instance.d.ts

@@ -0,0 +1,21 @@
+/**
+ * This module stores the currently singleton instance of the scripting service.
+ * Client code should not use this module directly but should use the
+ * `getScriptingService` method instead.
+ *
+ * The active scripting service instance is set here to allow for a custom
+ * scripting service instance in a browser development environment. See
+ * `getScriptingService` for an example.
+ */
+import { type ScriptingServiceType } from "./scripting-service";
+/**
+ * Do not call this method directly! This method is only called when importing
+ * the scripting service to set the singleton instance.
+ * @private
+ */
+export declare const setScriptingServiceInstance: (scriptingService: ScriptingServiceType) => void;
+/**
+ * Do not call this method directly! Use `getScriptingService` instead.
+ * @private
+ */
+export declare const getScriptingServiceInstance: () => ScriptingServiceType;

package/dist/src/scripting-service.d.ts

@@ -1,49 +1,60 @@
-import { editor as monaco, type IDisposable } from "monaco-editor";
-import type { ConsoleText } from "./components/OutputConsole.vue";
 import type { InputOutputModel } from "./components/InputOutputItem.vue";
 export type NodeSettings = {
     script: string;
     scriptUsedFlowVariable?: string;
 };
 declare class ScriptingService {
-    private _knimeService;
     private _jsonDataService;
-    private _settings;
+    private _closeService;
     private _eventHandlers;
     private _runEventPoller;
-    private _editorService;
     private _monacoLSPConnection;
-    protected _clearConsoleCallback?: Function;
     constructor();
     private eventPoller;
-    stopEventPoller(): void;
+    private stopEventPoller;
     sendToService(methodName: string, options?: any[]): Promise<any>;
     getInitialSettings(): Promise<NodeSettings>;
     saveSettings(settings: NodeSettings): Promise<void>;
     closeDialog(): Promise<void>;
     registerEventHandler(type: string, handler: (args: any) => void): void;
-    registerLanguageServerEventHandler(handler: (message: string) => void): void;
-    registerConsoleEventHandler(handler: (text: ConsoleText) => void): void;
-    sendToConsole(text: ConsoleText): void;
-    initEditorService(editor: monaco.IStandaloneCodeEditor, editorModel: monaco.ITextModel): void;
-    getScript(): string | null;
-    getSelectedLines(): string | null;
     connectToLanguageServer(): Promise<void>;
     configureLanguageServer(settings: any): Promise<void>;
-    setScript(newScript: string): void;
-    pasteToEditor(textToPaste: string): void;
-    setOnDidChangeContentListener(callback: Function): IDisposable | null;
     isCodeAssistantEnabled(): Promise<boolean>;
     isCodeAssistantInstalled(): Promise<boolean>;
     inputsAvailable(): Promise<boolean>;
     getFlowVariableInputs(): Promise<InputOutputModel>;
     getInputObjects(): Promise<InputOutputModel[]>;
     getOutputObjects(): Promise<InputOutputModel[]>;
-    clearConsole(): void;
-}
-export declare class ScriptingServiceInternal extends ScriptingService {
-    initClearConsoleCallback(clearConsoleCallback: () => void): void;
 }
 export type ScriptingServiceType = Pick<ScriptingService, keyof ScriptingService>;
-declare const getScriptingService: (mock?: Partial<ScriptingServiceType>) => ScriptingServiceInternal;
-export { getScriptingService };
+/**
+ * Get the singleton instance of the scripting service. The scripting service
+ * provides access to the backend KNIME instance.
+ *
+ * Note that it is possible to provide a custom scripting service instance in
+ * a browser development environment (see example).
+ *
+ * @returns the scripting service instance
+ * @example
+ * // Provide a custom scripting service instance in a browser development environment
+ * // vite.config.ts
+ *   resolve: {
+ *   alias: {
+ *     "./scripting-service-instance.js":
+ *       process.env.APP_ENV === "browser"
+ *         ? <path to scripting-service-instance-browser.ts>,
+ *         : "./scripting-service-instance.js",
+ *   },
+ * },
+ *
+ * // scripting-service-instance-browser.ts
+ * import { createScriptingServiceMock } from "@knime/scripting-editor/scripting-service-browser-mock";
+ * const scriptingService = createScriptingServiceMock({
+ *   // optional customizations
+ * });
+ * export const getScriptingServiceInstance = () => scriptingService;
+ * export const setScriptingServiceInstance = () => {};
+ */
+export declare const getScriptingService: () => ScriptingServiceType;
+export declare const initConsoleEventHandler: () => void;
+export {};