@knime/scripting-editor 0.0.106 → 0.0.108

package/dist/node_modules/@knime/ui-extension-service/dist/knime-ui-extension-service.dev.d.ts

@@ -0,0 +1,380 @@
+declare const AlertingService_base: {
+    new (baseService: any): {
+        baseService: any;
+    };
+    getInstance(): Promise<{
+        baseService: any;
+    }>;
+};
+export class AlertingService extends AlertingService_base {
+    sendAlert(params: any): void;
+}
+declare const CachingSelectionService_base: {
+    new (baseService: any): {
+        removeCallbacksMap: Map<any, any>;
+        /**
+             * Retrieves the initial data for the client-side UI Extension implementation from the extension configuration
+             * if it exists.
+             *
+             * @returns {Promise} node initial selection provided by the extension configuration.
+             */ initialSelection(): Promise<any>;
+        /**
+             * Replaces current selection with provided data.
+             * @param {SelectionMode} mode - the selection mode.
+             * @param {string[]} selection - will be passed as params to backend NodeService.updateDataPointSelection.
+             * @returns {Promise<unknown>} - based on backend implementation.
+             */ updateSelection(mode: SelectionMode, selection: string[]): Promise<unknown>;
+        /**
+             * Adds data to currently selected data set.
+             * @param {string[]} selection - will be passed as params to backend NodeService.updateDataPointSelection.
+             * @returns {Promise<unknown>} based on backend implementation.
+             */ add(selection: string[]): Promise<unknown>;
+        /**
+             * Removes data from currently selected data set.
+             * @param {string[]} selection - will be passed as params to backend NodeService.updateDataPointSelection.
+             * @returns {Promise<unknown>} based on backend implementation.
+             */ remove(selection: string[]): Promise<unknown>;
+        /**
+             * Replaces current selection with provided data.
+             * @param {string[]} selection - will be passed as params to backend NodeService.updateDataPointSelection.
+             * @returns {Promise<unknown>} based on backend implementation.
+             */ replace(selection: string[]): Promise<unknown>;
+        /**
+             * Adds callback that will be triggered on data selection change outside the scope of the view.
+             */ addOnSelectionChangeCallback(callback: any): void;
+        /**
+             * Removes previously added callback.
+             * @param {function} callback - that needs to be removed from events.
+             * @returns {void}
+             */ removeOnSelectionChangeCallback(callback: Function): void;
+        /**
+             * Handles publishing selection on selection change.
+             * @param {SelectionModes} selectionMode - with which the selection should be updates
+             * @param {array} rowKeys - data with which the selection should be updated
+             * @returns {Promise<any>}
+             */ publishOnSelectionChange(selectionMode: SelectionModes, rowKeys: array): Promise<any>;
+        baseService: any;
+    };
+    getInstance(): Promise<{
+        baseService: any;
+    }>;
+};
+export class CachingSelectionService extends CachingSelectionService_base {
+    cachedSelection: Set<any>;
+    addBackendSelection({ mode: mode, selection: selection }: {
+        mode: any;
+        selection?: never[] | undefined;
+    }): void;
+    add(selection: any): Promise<unknown>;
+    addToChache(selection: any): void;
+    remove(selection: any): Promise<unknown>;
+    removeFromCache(selection: any): void;
+    replace(selection: any): Promise<unknown>;
+    replaceCache(selection: any): void;
+    getCachedSelection(): Set<any>;
+}
+declare const ColorService_base: {
+    new (baseService: any): {
+        baseService: any;
+    };
+    getInstance(): Promise<{
+        baseService: any;
+    }>;
+};
+export class ColorService extends ColorService_base {
+    /**
+         * @param {KnimeService} knimeService - knimeService instance which is used to communicate
+         *      with the framework.
+         */
+    constructor(baseService: any);
+    colorModels: any;
+    columnNamesColorModel: any;
+    getColorHandler(columnName: any, suppressWarning?: boolean): {
+        getColor(value: any): any;
+        colorModel: any;
+        getColorModel(): any;
+    } | {
+        rgbMin: any;
+        rgbMax: any;
+        getRatio: (value: any) => number;
+        getColor(value: any): string;
+        colorModel: any;
+        getColorModel(): any;
+    } | null;
+    getColumnNamesColorHandler(): {
+        getColor(value: any): any;
+        colorModel: any;
+        getColorModel(): any;
+    } | null;
+}
+export class DefaultSettingComparator {
+    isModified(settings: any): boolean;
+    setSettings(cleanSettings: any): void;
+    cleanState: void | undefined;
+    /**
+         * Transformation applied to settings before they are compared against each other with {@link equals}
+         *
+         * Implementation required
+         */
+    toInternalState(_cleanSettings: any): void;
+    /**
+         * @param _newState the internal state representation of possibly modified settings
+         * @param _cleanState a clean internal state
+         * @returns true if the {@link _newState} is clean
+         *
+         * Implementation required
+         */
+    equals(_newState: any, _cleanState: any): void;
+}
+declare const DialogService_base: {
+    new (baseService: any): {
+        baseService: any;
+    };
+    getInstance(): Promise<{
+        baseService: any;
+    }>;
+};
+export class DialogService extends DialogService_base {
+    removeCallbacksMap: Map<any, any>;
+    /**
+         * @returns {boolean} - true, if the node this dialog belongs to also has a node view, otherwise false
+         */ hasNodeView(): boolean;
+    /**
+         * @returns {boolean} - true, if the dialog settings can't be saved (e.g. meaning that the OK-button is disabled);
+         *         otherwise false
+         */ isWriteProtected(): boolean;
+    /**
+         * Call this method in order to track modifications in settings and expose specific dirty states relevant for the embedder.
+         * E.g. for a view setting which is exposed as a variable if the value of the setting is modified, the node is to be reset
+         * on apply which is relevant information for the embedder.
+         */ registerSettings(modelOrView: any): any;
+    /**
+         * This needs to be called in order to enable listening to push events of the embedder to apply the settings in the dialog.
+         */ setApplyListener(applyListener: any): any;
+    setControlsVisibility(param: any): void;
+    /**
+         * Adds callback that will be triggered when the display mode of the dialog changes.
+         */ addOnDisplayModeChangeCallback(callback: any): void;
+    getInitialDisplayMode(): "large" | "small";
+    /**
+         * Removes previously added callback.
+         * @param {function} callback - that needs to be removed from events.
+         * @returns {void}
+         */ removeOnDisplayModeChangeCallback(callback: Function): void;
+}
+declare const ImageGenerationService_base: {
+    new (baseService: any): {
+        baseService: any;
+    };
+    getInstance(): Promise<{
+        baseService: any;
+    }>;
+};
+export class ImageGenerationService extends ImageGenerationService_base {
+    isImageGenerationActive(): boolean;
+    /**
+         * @throws {Error} if image generation is not active.
+         */ getImageFormat(): any;
+    /**
+         * Called when an image has been generated.
+         * @param {string} image - the generated image as string
+         * @return {void}
+         */ imageGenerated(image: string): void;
+}
+declare const JsonDataService_base: {
+    new (baseService: any): {
+        baseService: any;
+    };
+    getInstance(): Promise<{
+        baseService: any;
+    }>;
+};
+export class JsonDataService extends JsonDataService_base {
+    /**
+         * Calls the node data service with optional request body. The service to call is specified by the service type
+         * and needs to correspond directly to a @see DataServiceType supported by the node.
+         *
+         * @param {DataServiceType} dataServiceType - the data service type.
+         * @param {string} [request] - an optional request payload.
+         * @returns {Promise} rejected or resolved depending on backend response.
+         */
+    callDataService(serviceType: any, request?: string): Promise<any>;
+    /**
+         * Retrieves the initial data for the client-side UI Extension implementation from either the local configuration
+         * (if it exists) or by fetching the data from the node DataService implementation.
+         *
+         * @returns {Promise} node initial data provided by the local configuration or by fetching from the DataService.
+         */ initialData(): Promise<any>;
+    /**
+         * Retrieve data from the node using the @see DataServiceType.DATA api. Different method names can be registered
+         * with the data service in the node implementation to provide targets (specified by the {@param method}). Any
+         * optional parameter will be provided directly to the data service target and can be used to specify the nature of
+         * the data returned.
+         *
+         * @param {Object} params - parameter options.
+         * @param {string} [params.method] - optional target method in the node's DataService implementation
+         *      (default 'getData').
+         * @param {[]} [params.options] - optional options that should be passed to called method.
+         * @returns {Promise} rejected or resolved depending on backend response.
+         */ data(params?: {
+        method?: string | undefined;
+        options?: [] | undefined;
+    }): Promise<any>;
+    /**
+         * Sends the current client-side data to the backend to be persisted. A data getter method which returns the
+         * data to be applied/saved should be registered *prior* to invoking this method. If none is registered, a
+         * default payload of "null" will be sent instead.
+         *
+         * @returns a boolean whether the data was successfully applied.
+         */ applyData(data: any): Promise<{
+        isApplied: boolean;
+    }>;
+    handleError(error: any): void;
+    handleWarnings(warningMessages: any): void;
+}
+export namespace KnimeUtils {
+    export { generateRequestId };
+    export { createJsonRpcRequest };
+}
+declare const NominalColorHandler_base: {
+    new (model: any): {
+        colorModel: any;
+        getColorModel(): any;
+    };
+};
+export class NominalColorHandler extends NominalColorHandler_base {
+    getColor(value: any): any;
+}
+declare const NumericColorHandler_base: {
+    new (model: any): {
+        colorModel: any;
+        getColorModel(): any;
+    };
+};
+export class NumericColorHandler extends NumericColorHandler_base {
+    rgbMin: any;
+    rgbMax: any;
+    getRatio: (value: any) => number;
+    getColor(value: any): string;
+}
+declare const ReportingService_base: {
+    new (baseService: any): {
+        baseService: any;
+    };
+    getInstance(): Promise<{
+        baseService: any;
+    }>;
+};
+export class ReportingService extends ReportingService_base {
+    isReportingActive(): any;
+    getImageFormat(): any;
+    /**
+         * Informs that the view is rendered and sets the respective reporting content.
+         * @param {false | string} reportingContent - the reporting content (html as string) to be set or false if the reporting content is to be read from the dom.
+         * @return {void}
+         */ setReportingContent(reportingContent: false | string): void;
+    /**
+         * Sets the view as rendered. The reporting content will be read from the dom.
+         * @return {void}
+         */ setRenderCompleted(): void;
+}
+declare const ResourceService_base: {
+    new (baseService: any): {
+        baseService: any;
+    };
+    getInstance(): Promise<{
+        baseService: any;
+    }>;
+};
+export class ResourceService extends ResourceService_base {
+    getResourceUrl(path: any): any;
+}
+declare const SelectionService_base: {
+    new (baseService: any): {
+        baseService: any;
+    };
+    getInstance(): Promise<{
+        baseService: any;
+    }>;
+};
+export class SelectionService extends SelectionService_base {
+    removeCallbacksMap: Map<any, any>;
+    /**
+         * Retrieves the initial data for the client-side UI Extension implementation from the extension configuration
+         * if it exists.
+         *
+         * @returns {Promise} node initial selection provided by the extension configuration.
+         */ initialSelection(): Promise<any>;
+    /**
+         * Replaces current selection with provided data.
+         * @param {SelectionMode} mode - the selection mode.
+         * @param {string[]} selection - will be passed as params to backend NodeService.updateDataPointSelection.
+         * @returns {Promise<unknown>} - based on backend implementation.
+         */ updateSelection(mode: SelectionMode, selection: string[]): Promise<unknown>;
+    /**
+         * Adds data to currently selected data set.
+         * @param {string[]} selection - will be passed as params to backend NodeService.updateDataPointSelection.
+         * @returns {Promise<unknown>} based on backend implementation.
+         */ add(selection: string[]): Promise<unknown>;
+    /**
+         * Removes data from currently selected data set.
+         * @param {string[]} selection - will be passed as params to backend NodeService.updateDataPointSelection.
+         * @returns {Promise<unknown>} based on backend implementation.
+         */ remove(selection: string[]): Promise<unknown>;
+    /**
+         * Replaces current selection with provided data.
+         * @param {string[]} selection - will be passed as params to backend NodeService.updateDataPointSelection.
+         * @returns {Promise<unknown>} based on backend implementation.
+         */ replace(selection: string[]): Promise<unknown>;
+    /**
+         * Adds callback that will be triggered on data selection change outside the scope of the view.
+         */ addOnSelectionChangeCallback(callback: any): void;
+    /**
+         * Removes previously added callback.
+         * @param {function} callback - that needs to be removed from events.
+         * @returns {void}
+         */ removeOnSelectionChangeCallback(callback: Function): void;
+    /**
+         * Handles publishing selection on selection change.
+         * @param {SelectionModes} selectionMode - with which the selection should be updates
+         * @param {array} rowKeys - data with which the selection should be updated
+         * @returns {Promise<any>}
+         */ publishOnSelectionChange(selectionMode: SelectionModes, rowKeys: array): Promise<any>;
+}
+declare const SharedDataService_base: {
+    new (baseService: any): {
+        baseService: any;
+    };
+    getInstance(): Promise<{
+        baseService: any;
+    }>;
+};
+export class SharedDataService extends SharedDataService_base {
+    /**
+         * Publish updated data to the embedder.
+         * This may be used on embedder side by sending the data to dependent other UI Extensions.
+         * @param {T} data - the updated data.
+         * @returns {void}
+         */
+    shareData(data: T): void;
+    /**
+         * Adds callback that will be triggered when data shared by other UI Extensions changes.
+         * @param {Function} callback - called on shared data change.
+         * @returns {() => void} - method for removing the listener again
+         */ addSharedDataListener(callback: Function): () => void;
+    /**
+         * Similarly to {@link addSharedDataListener} this method can be used to receive the current data shared
+         * by other UIExtensions: It returns the current state of shared data at the moment
+         * the present one is initiated.
+         *
+         * If no such date have been shared, null is returned.
+         */ getInitialSharedData(): any;
+}
+declare function generateRequestId(): number;
+declare function createJsonRpcRequest(method: any, params?: any[]): {
+    jsonrpc: string;
+    method: any;
+    params: any[];
+    id: number;
+};
+export {};

package/dist/node_modules/@knime/utils/src/capitalize.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Uppercases first letter of string
+ * @param string to be capitalized first string, e.g. "workflow"
+ * @return Capitalized String, e.g. "Workflow"
+ */
+export declare const capitalize: (input: string) => string;
+declare const formats: {
+    readonly customFormat: (input: string, delimiter: string) => string;
+    readonly kebabFormat: (input: string) => string;
+    readonly snakeFormat: (input: string) => string;
+    readonly camelPascalCase: (input: string) => string;
+};
+type CaseFormatterOptions = {
+    string: string;
+    delimiter?: string;
+    format?: keyof typeof formats;
+};
+export declare const caseFormatter: ({ string, delimiter, format, }: CaseFormatterOptions) => string;
+export {};

package/dist/node_modules/@knime/utils/src/dateMinMaxCheck.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Check if date is before min.
+ * @param date
+ * @param min
+ * @param checkDate - check date part (year, day, month).
+ * @param checkTime - check time part (hour, minutes etc.).
+ * @returns whether limit is kept or not.
+ */
+export declare const isBeforeMinDate: (date: Date, min: Date | null, checkDate: boolean, checkTime: boolean) => boolean;
+/**
+ * Check
+ * @param date - date to check.
+ * @param max - maximum date.
+ * @param checkDate - check date part (year, day, month).
+ * @param checkTime - check time part (hour, minutes etc.).
+ * @returns whether limit is kept or not.
+ */
+export declare const isAfterMaxDate: (date: Date, max: Date | null, checkDate: boolean, checkTime: boolean) => boolean;

package/dist/node_modules/@knime/utils/src/debounce.d.ts

@@ -0,0 +1,3 @@
+type CallbackFunc<T> = (value: T, index: number) => void;
+declare const debounce: <T>(callback: CallbackFunc<T>, wait: number) => (...args: Parameters<typeof callback>) => void;
+export default debounce;

package/dist/node_modules/@knime/utils/src/fileExtensions.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Gets the file extension
+ * @param nameOrPath can take a full file name (e.g "file.txt") or a path to a file
+ * (e.g "file://path/to/file.txt" OR "/path/to/file.txt")
+ * @returns just the file extension (e.g "txt")
+ */
+export declare const getFileExtension: (nameOrPath: string) => string;
+export declare const knimeFileFormats: {
+    KNAR: Readonly<{
+        extension: "knar";
+        mimeType: "application/vnd.knime.workflow-group+zip";
+        matches(file: File): boolean;
+    }>;
+    KNWF: Readonly<{
+        extension: "knwf";
+        mimeType: "application/vnd.knime.workflow+zip";
+        matches(file: File): boolean;
+        /**
+         * Gets the name of a .knwf file without the extension. If the file is not
+         * matched as a .knwf file then this function will return the default value,
+         * which is empty string ("") if param is not provided
+         */
+        getNameOrDefault(file: File, defaultValue?: string): string;
+    }>;
+};
+/**
+ * Gets the mime type from a given file. Defaults to `application/octet-stream`
+ * if mimeType cannot be detected
+ * @param file File
+ * @returns mimeType
+ */
+export declare const getFileMimeType: (file: File) => string;

package/dist/node_modules/@knime/utils/src/fileTypeIcons.d.ts

@@ -0,0 +1,20 @@
+export declare const icons: {
+    csvIcon: import('vue').Component;
+    docxIcon: import('vue').Component;
+    htmlIcon: import('vue').Component;
+    mdIcon: import('vue').Component;
+    odpIcon: import('vue').Component;
+    odsIcon: import('vue').Component;
+    odtIcon: import('vue').Component;
+    pdfIcon: import('vue').Component;
+    pptxIcon: import('vue').Component;
+    psIcon: import('vue').Component;
+    xlsIcon: import('vue').Component;
+    xlsxIcon: import('vue').Component;
+    xmlIcon: import('vue').Component;
+    zipIcon: import('vue').Component;
+    exeIcon: import('vue').Component;
+    txtIcon: import('vue').Component;
+    fileIcon: import('vue').Component;
+};
+export declare const isIconExisting: (iconName: string) => boolean;

package/dist/node_modules/@knime/utils/src/filters.d.ts

@@ -0,0 +1,12 @@
+/**
+ * These definitions can be used to filter an array. Each entry should contain a method normalize which can be used to
+ * compile any filter settings and a method "test" which takes the compiled result, additional settings and the item to
+ * be matched/filtered
+ * */
+interface FilterDefinition<SearchTerm, Normalized, Testable> {
+    id: string;
+    normalize: (searchTerm: SearchTerm, caseSensitiveSearch: boolean) => Normalized;
+    test: (text: Testable, normalizedSearchTerm: Normalized, caseSensitiveSearch: boolean, inverseSearch: boolean) => boolean;
+}
+export declare const filters: Record<string, FilterDefinition<unknown, unknown, unknown>>;
+export {};

package/dist/node_modules/@knime/utils/src/format.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Converts the specified date String to human readable text containing the day, month, and year.
+ * Example: '2018-07-31T09:44:31+00:00' => 'Jul 31, 2018'
+ *
+ * @param dateString String representation of the Date to format
+ * @param useTimeZone to set the timeZone where the user is located, and display local date and time
+ * @returns human readable date String
+ */
+export declare const formatDateString: (dateString: string | number, useTimeZone?: boolean) => string;
+/**
+ * Converts the specified time String to human readable text containing the hour (12-hour) and minute.
+ * Example: '2018-07-31T09:44:31+00:00' => '9:44 AM'
+ *
+ * @param timeString String representation of the Date (including time) to format
+ * @param useTimeZone to set the timeZone where the user is located, and display local date and time
+ * @returns human readable time String
+ */
+export declare const formatTimeString: (timeString: string | number, useTimeZone?: boolean) => string;
+/**
+ * Converts the specified time String to human readable text containing the date (day, month, year) and time (hour,
+ * minute; 12-hour).
+ * Example: '2018-07-31T09:44:31+00:00' => 'Jul 31, 2018 9:44 AM'
+ *
+ * @param dateTimeString String representation of the Date (including time and date) to format
+ * @param useTimeZone to set the timeZone where the user is located, and display local date and time
+ * @returns human readable date/time String
+ */
+export declare const formatDateTimeString: (dateTimeString: string | number, useTimeZone?: boolean) => string;
+/**
+ * Converts the specified date and time to the user time zone with option to display (day, month, year) only or with time (hour,
+ * minute; 12-hour).
+ *
+ * @param showTime String representation of the Date to convert and format
+ * @param String | number} date String representation of the Date to convert and format
+ * @returns human readable date/time String converted to user time zone
+ */
+export declare const formatLocalDateTimeString: (date: string, showTime: boolean) => string;

package/dist/node_modules/@knime/utils/src/formatHotkeys.d.ts

@@ -0,0 +1,16 @@
+type Keys = "F1" | "F2" | "F3" | "F4" | "F5" | "F6" | "F7" | "F8" | "F9" | "F10" | "F11" | "F12" | "PageUp" | "PageDown" | "ArrowUp" | "ArrowRight" | "ArrowDown" | "ArrowLeft" | "Delete" | "Enter" | "Backspace" | "Home" | "End" | " ";
+type Modifiers = "CtrlOrCmd" | "Ctrl" | "Alt" | "Shift";
+type LooseAutoComplete<T extends string> = T | Omit<string, T>;
+export type NumberRange = `${number}-${number}`;
+export type KnownHotkey = Keys | Modifiers | NumberRange;
+export type Hotkey = LooseAutoComplete<Keys | Modifiers>;
+/**
+ * Returns a string representation of a single hotkey. Replaces some special key names with symbols
+ */
+export declare const formatHotkey: (hotkey: Hotkey) => string;
+export declare const getDefaultSeparator: () => string;
+/**
+ * Returns a string representation of a list of hotkeys. Replaces some special key names with symbols
+ */
+export declare const formatHotkeys: (hotkeys: Array<Hotkey>, getSeparator?: () => string) => string;
+export {};

package/dist/node_modules/@knime/utils/src/getDeepActiveElement.d.ts

@@ -0,0 +1,2 @@
+declare const getDeepActiveElement: () => Element | null;
+export default getDeepActiveElement;

package/dist/node_modules/@knime/utils/src/getWrappedAroundIndex.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Since (a % b) yields a negative outcome for negative a, we need this method in order
+ *  to correctly compute wrapped around indices in lists
+ * @param {number} index an arbitrary integer
+ * @param {number} length a positive integer
+ * @returns {number} the non-negative modulo outcome
+ */
+declare const _default: (index: number, length: number) => number;
+export default _default;

package/dist/node_modules/@knime/utils/src/hotkeys.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Checks if any modifier key (Ctrl, Meta, Alt, or Shift) is pressed.
+ * @param {KeyboardEvent} event - The keyboard event to check.
+ * @returns {boolean} True if a modifier key is pressed, otherwise false.
+ */
+export declare const isModifierKeyPressed: (event: KeyboardEvent) => boolean;
+/**
+ * Checks if a specific key (or keys) were pressed without any modifier keys.
+ * @param {KeyboardEvent} event - The keyboard event to check.
+ * @param {string | string[]} keys - The key or keys to check for.
+ * @returns {boolean} True if the specified key(s) were pressed without modifiers, otherwise false.
+ */
+export declare const isKeyWithoutModifiers: (event: KeyboardEvent, keys: string | string[]) => boolean;
+/**
+ *
+ * @returns name of the primary modifier key for the current platform
+ */
+export declare const getMetaOrCtrlKey: () => "ctrlKey" | "metaKey";

package/dist/node_modules/@knime/utils/src/index.d.ts

@@ -0,0 +1,32 @@
+import { capitalize, caseFormatter } from './capitalize';
+import { isAfterMaxDate, isBeforeMinDate } from './dateMinMaxCheck';
+import { default as debounce } from './debounce';
+import { icons, isIconExisting } from './fileTypeIcons';
+import { filters } from './filters';
+import { formatDateString, formatDateTimeString, formatLocalDateTimeString, formatTimeString } from './format';
+import { Hotkey as _Hotkey, KnownHotkey as _KnownHotkey } from './formatHotkeys';
+import { default as getDeepActiveElement } from './getDeepActiveElement';
+import { default as getWrappedAroundIndex } from './getWrappedAroundIndex';
+import { default as getLocalTimeZone } from './localTimezone';
+import { default as numIntegerDigits } from './numIntegerDigits';
+import { default as sleep } from './sleep';
+import { default as truncateString } from './truncateString';
+import { default as updateDate } from './updateDate';
+import { default as updateTime } from './updateTime';
+import { UploaderManagerConfig as _UploadManagerConfig, UploadStateName as _UploadStateName } from './uploadManager';
+import * as intervalUtils from "./intervalUtils";
+import * as navigatorUtils from "./navigator";
+import * as promise from "./promise";
+import * as uploadManager from "./uploadManager";
+declare const hotkeys: {
+    formatHotkeys: (hotkeys: Array<_Hotkey>, getSeparator?: () => string) => string;
+    formatHotkey: (hotkey: _Hotkey) => string;
+    getDefaultSeparator: () => string;
+};
+export type Hotkey = _Hotkey;
+export type KnownHotkey = _KnownHotkey;
+export type UploaderConfig = _UploadManagerConfig;
+export type UploadStateName = _UploadStateName;
+export * from './fileExtensions';
+export * from './hotkeys';
+export { uploadManager, promise, capitalize, caseFormatter, debounce, filters, formatDateString, formatDateTimeString, getDeepActiveElement, formatLocalDateTimeString, formatTimeString, getLocalTimeZone, getWrappedAroundIndex, hotkeys, icons, isAfterMaxDate, isBeforeMinDate, isIconExisting, intervalUtils, navigatorUtils, numIntegerDigits, sleep, truncateString, updateDate, updateTime, };