@eccenca/gui-elements 6.3.0 → 22.0.1

package/dist/types/components/Tag/Tag.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="react" />
+import { TagProps as BlueprintTagProps } from "@blueprintjs/core";
+import Color from "color";
+interface TagProps extends Omit<BlueprintTagProps, "active" | "fill" | "large" | "multiline" | "intent" | "rightIcon" | "round"> {
+    /**
+     * Sets the background color of a tag, depends on the `Color` object provided by the
+     * [npm color module](https://www.npmjs.com/package/color) v3. You can use it with
+     * all allowed [CSS color values](https://developer.mozilla.org/de/docs/Web/CSS/color_value).
+     *
+     * The front color is set automatically, so the tag label is always readable.
+     */
+    backgroundColor?: Color | string;
+    /**
+     * visual appearance and "thickness" of the tag
+     */
+    emphasis?: "stronger" | "strong" | "normal" | "weak" | "weaker";
+    /**
+     * display tag in a small version
+     */
+    small?: boolean;
+    /**
+     * **deprecated**, use `minimal=false` plus `emphasis="stronger"`
+     */
+    emphasized?: never;
+}
+declare function Tag({ children, className, emphasis, minimal, small, backgroundColor, ...otherProps }: TagProps): JSX.Element;
+export default Tag;

package/dist/types/components/Tag/TagList.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare function TagList({ children, className, label, ...otherProps }: any): JSX.Element;
+export default TagList;

package/dist/types/components/TextField/SearchField.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="react" />
+import { TextFieldProps } from "./TextField";
+import { TestableComponent } from "../../components/interfaces";
+interface SearchFieldProps extends TestableComponent, Omit<TextFieldProps, "placeholder | hasStatePrimary | hasStateSuccess | hasStateWarning | hasStateDanger | fullWidth"> {
+    /**
+    * Placeholder text for search box.
+    */
+    emptySearchInputMessage?: string;
+    /**
+    * Event handler to reset search input.
+    * If set then `rightElement` is automatically set with an action button to trigger the handler.
+    */
+    onClearanceHandler?: () => void;
+    /**
+    * Tooltip to show for the clear button.
+    */
+    onClearanceText?: string;
+}
+/**
+ * Special `TextField` element for search term inputs.
+ */
+declare function SearchField({ className, emptySearchInputMessage, onClearanceHandler, onClearanceText, leftIcon, ...otherProps }: SearchFieldProps): JSX.Element;
+export default SearchField;

package/dist/types/components/TextField/TextArea.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="react" />
+import { TextAreaProps as BlueprintTextAreaProps } from "@blueprintjs/core";
+interface TextAreaProps extends Partial<BlueprintTextAreaProps> {
+    /**
+     * when set to true the input takes a blue border color
+     */
+    hasStatePrimary?: boolean;
+    /**
+     * when set to true the input takes a green border color
+     */
+    hasStateSuccess?: boolean;
+    /**
+     * when set to true the input takes an orange border color
+     */
+    hasStateWarning?: boolean;
+    /**
+     * when set to true the input takes a red border color
+     */
+    hasStateDanger?: boolean;
+}
+declare function TextArea({ className, hasStatePrimary, hasStateSuccess, hasStateWarning, hasStateDanger, rows, ...otherProps }: TextAreaProps): JSX.Element;
+export default TextArea;

package/dist/types/components/TextField/TextField.d.ts

@@ -0,0 +1,34 @@
+/// <reference types="react" />
+import { MaybeElement, HTMLInputProps, InputGroupProps } from "@blueprintjs/core";
+import { ValidIconName } from "../Icon/canonicalIconNames";
+export interface TextFieldProps extends Partial<Omit<InputGroupProps, "intent" | "leftIcon"> & HTMLInputProps> {
+    /**
+    * The input element is displayed with primary color scheme.
+    */
+    hasStatePrimary?: boolean;
+    /**
+    * The input element is displayed with success (some type of green) color scheme.
+    */
+    hasStateSuccess?: boolean;
+    /**
+    * The input element is displayed with warning (some type of orange) color scheme.
+    */
+    hasStateWarning?: boolean;
+    /**
+    * The input element is displayed with danger (some type of red) color scheme.
+    */
+    hasStateDanger?: boolean;
+    /**
+     * The input element uses the full horizontal width of the parent container.
+     */
+    fullWidth?: boolean;
+    /**
+     * Left aligned icon, can be a canonical icon name or an `Icon` element.
+     */
+    leftIcon?: ValidIconName | MaybeElement;
+}
+/**
+  * Text input field.
+  */
+declare function TextField({ className, hasStatePrimary, hasStateSuccess, hasStateWarning, hasStateDanger, fullWidth, leftIcon, ...otherProps }: TextFieldProps): JSX.Element;
+export default TextField;

package/dist/types/components/Toolbar/Toolbar.d.ts

@@ -0,0 +1,18 @@
+import React from "react";
+interface ToolbarProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Allow sections to break up into multiple lines when there is not enough space available.
+     * Only makes sense for horizontal toolbars.
+     */
+    noWrap?: boolean;
+    /**
+     * Toolbar displays vertically like a column.
+     * Can be used for toolbars in sidebars.
+     */
+    verticalStack?: boolean;
+}
+/**
+ * Element to group user-interaction elements.
+ */
+declare function Toolbar({ children, className, noWrap, verticalStack, ...restProps }: ToolbarProps): JSX.Element;
+export default Toolbar;

package/dist/types/components/Toolbar/ToolbarSection.d.ts

@@ -0,0 +1,22 @@
+import React from "react";
+interface ToolbarSectionProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+    * Is allowed to allocate more space than necessary to show all children.
+    */
+    canGrow?: boolean;
+    /**
+    * Allow element to get shrinked if there is not enough space to show all content.
+    * This only makes sense if it contains children that are elastic in its size.
+    */
+    canShrink?: boolean;
+    /**
+    * Hides content that overflows available space.
+    */
+    hideOverflow?: boolean;
+}
+/**
+ * Provides element to group toolbar elements together.
+ * It can be configured how dynamic it is displayed regarding provided space inside the `Toolbar` parent.
+ */
+declare function ToolbarSection({ children, className, canGrow, canShrink, hideOverflow, ...otherProps }: ToolbarSectionProps): JSX.Element;
+export default ToolbarSection;

package/dist/types/components/Tooltip/Tooltip.d.ts

@@ -0,0 +1,17 @@
+import React from "react";
+import { TooltipProps as BlueprintTooltipProps } from "@blueprintjs/core";
+export interface TooltipProps {
+    className?: string;
+    addIndicator?: boolean;
+    /** Blueprint specific tooltip props */
+    tooltipProps?: Partial<BlueprintTooltipProps>;
+    /** The content that is displayed when hovering over the tooltip area. */
+    content: JSX.Element | string;
+    /** The size specifies the dimension the element can maximal grow. */
+    size?: "small" | "medium" | "large";
+    children: React.ReactNode | React.ReactNode[];
+    /** @deprecated Use tooltipProps for Blueprint specific props or add concrete properties in all other cases. */
+    [key: string]: any;
+}
+declare function Tooltip({ children, content, className, size, addIndicator, tooltipProps, ...otherProps }: TooltipProps): JSX.Element;
+export default Tooltip;

package/dist/types/components/Typography/Highlighter.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="react" />
+interface IHighlighterProps {
+    label?: string;
+    searchValue?: string;
+}
+/**
+ * Returns a highlighted string according to the words of the search query.
+ * @param label       The string to highlight.
+ * @param searchValue The mutli-word search query from which single words should be highlighted in the label.
+ */
+declare function Highlighter({ label, searchValue }: IHighlighterProps): JSX.Element;
+/** Extracts search words separated by white space. */
+export declare function extractSearchWords(textQuery: string, toLowerCase?: boolean): string[];
+/** Returns true if all search words are included in the given text */
+export declare function matchesAllWords(text: string, searchWords: string[]): boolean;
+/** Creates a case-insensitive multi-word regex, that matches any of the given words. */
+export declare function createMultiWordRegex(multiWordQuery: string[], global?: boolean): RegExp;
+export default Highlighter;

package/dist/types/components/Typography/HtmlContentBlock.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+declare function HtmlContentBlock({ className, children, small, large, // currently unsupported
+muted, // currently unsupported
+disabled, // currently unsupported
+...otherProps }: any): JSX.Element;
+export default HtmlContentBlock;

package/dist/types/components/Typography/OverflowText.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+interface IProps {
+    ellipsis?: "reverse" | "none";
+    inline?: boolean;
+    passDown?: boolean;
+    className?: string;
+    useHtmlElement?: "p" | "div" | "span";
+    [key: string]: any;
+}
+/** Prevents text from overflowing. */
+declare function OverflowText({ className, children, ellipsis, inline, passDown, useHtmlElement, ...otherProps }: IProps): JSX.Element;
+export default OverflowText;

package/dist/types/components/Typography/WhiteSpaceContainer.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+declare function WhiteSpaceContainer({ className, children, marginTop, // tiny, small, regular, large, xlarge
+marginRight, marginBottom, marginLeft, paddingTop, // tiny, small, regular, large, xlarge
+paddingRight, paddingBottom, paddingLeft, ...otherProps }: any): JSX.Element;
+export default WhiteSpaceContainer;

package/dist/types/components/Typography/classnames.d.ts

@@ -0,0 +1,7 @@
+export declare const NOOVERFLOW: string;
+export declare const FORCELINEBREAK: string;
+export declare const PREVENTLINEBREAK: string;
+export declare const LARGE: string;
+export declare const SMALL: string;
+export declare const MUTED: string;
+export declare const DISABLED: string;

package/dist/types/components/Workspace/WorkspaceContent.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare function WorkspaceContent({ children, className, ...restProps }: any): JSX.Element;
+export default WorkspaceContent;

package/dist/types/components/Workspace/WorkspaceHeader.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+interface IWorkspaceHeaderProps extends React.HTMLAttributes<HTMLDivElement> {
+    children?: any;
+    /**
+        space-delimited list of class names
+    */
+    className?: string;
+}
+declare function WorkspaceHeader({ children, className, ...otherProps }: IWorkspaceHeaderProps): JSX.Element;
+export default WorkspaceHeader;

package/dist/types/components/Workspace/WorkspaceMain.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare function WorkspaceMain({ children, className, ...restProps }: any): JSX.Element;
+export default WorkspaceMain;

package/dist/types/components/Workspace/WorkspaceSide.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare function WorkspaceSide({ children, className, ...restProps }: any): JSX.Element;
+export default WorkspaceSide;

package/dist/types/components/interfaces.d.ts

@@ -0,0 +1,3 @@
+export interface TestableComponent {
+    "data-test-id"?: string;
+}

package/dist/types/configuration/constants.d.ts

@@ -0,0 +1 @@
+export declare const CLASSPREFIX = "eccgui";

package/dist/types/extensions/react-flow/edges/EdgeDefault.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { EdgeProps as ReactFlowEdgeProps } from "react-flow-renderer/dist/types";
+export interface EdgeDefaultDataProps {
+    pathGlowWidth?: number;
+}
+export interface EdgeDefaultProps extends ReactFlowEdgeProps {
+    data?: EdgeDefaultDataProps;
+    drawSvgPath?: (edge: ReactFlowEdgeProps) => string;
+}
+export declare const EdgeDefault: React.MemoExoticComponent<(edge: EdgeDefaultProps) => JSX.Element>;

package/dist/types/extensions/react-flow/edges/EdgeStep.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { EdgeDefaultProps, EdgeDefaultDataProps } from "./EdgeDefault";
+export interface EdgeStepDataProps extends EdgeDefaultDataProps {
+    stepCornerRadius?: number;
+}
+export interface EdgeStepProps extends EdgeDefaultProps {
+    data?: EdgeStepDataProps;
+}
+export declare const EdgeStep: React.MemoExoticComponent<(edge: EdgeStepProps) => JSX.Element>;

package/dist/types/extensions/react-flow/edges/EdgeTools.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { IPopoverProps as IBlueprintPopoverProps } from "@blueprintjs/core";
+interface PosOffset {
+    left: number;
+    top: number;
+}
+export interface EdgeToolsProps extends IBlueprintPopoverProps {
+    posOffset: PosOffset;
+    children: string | JSX.Element | JSX.Element[];
+}
+export declare const EdgeTools: React.MemoExoticComponent<({ posOffset, children, ...otherProps }: EdgeToolsProps) => JSX.Element>;
+export {};

package/dist/types/extensions/react-flow/edges/edgeTypes.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+export declare const edgeTypes: {
+    default: import("react").MemoExoticComponent<(edge: import("./EdgeDefault").EdgeDefaultProps) => JSX.Element>;
+    straight: import("react").MemoExoticComponent<(edge: import("./EdgeDefault").EdgeDefaultProps) => JSX.Element>;
+    step: import("react").MemoExoticComponent<(edge: import("./EdgeStep").EdgeStepProps) => JSX.Element>;
+    smoothstep: import("react").MemoExoticComponent<(edge: import("./EdgeStep").EdgeStepProps) => JSX.Element>;
+    implicitEdge: import("react").MemoExoticComponent<(edge: import("./EdgeDefault").EdgeDefaultProps) => JSX.Element>;
+    importEdge: import("react").MemoExoticComponent<(edge: import("./EdgeDefault").EdgeDefaultProps) => JSX.Element>;
+    subclassEdge: import("react").MemoExoticComponent<(edge: import("./EdgeDefault").EdgeDefaultProps) => JSX.Element>;
+    subpropertyEdge: import("react").MemoExoticComponent<(edge: import("./EdgeDefault").EdgeDefaultProps) => JSX.Element>;
+    rdftypeEdge: import("react").MemoExoticComponent<(edge: import("./EdgeDefault").EdgeDefaultProps) => JSX.Element>;
+    successStep: import("react").MemoExoticComponent<(edge: import("./EdgeStep").EdgeStepProps) => JSX.Element>;
+    warningStep: import("react").MemoExoticComponent<(edge: import("./EdgeStep").EdgeStepProps) => JSX.Element>;
+    dangerStep: import("react").MemoExoticComponent<(edge: import("./EdgeStep").EdgeStepProps) => JSX.Element>;
+};

package/dist/types/extensions/react-flow/edges/utils.d.ts

@@ -0,0 +1,4 @@
+import { EdgeDefaultProps } from "./EdgeDefault";
+import { EdgeStepProps } from "./EdgeStep";
+export declare const drawEdgeStraight: ({ sourceX, sourceY, targetX, targetY, }: EdgeDefaultProps) => string;
+export declare const drawEdgeStep: ({ sourceX, sourceY, sourcePosition, targetX, targetY, targetPosition, data, }: EdgeStepProps) => string;

package/dist/types/extensions/react-flow/handles/HandleContent.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+export interface HandleContentProps {
+    children?: JSX.Element | string;
+    extendedTooltip?: JSX.Element | string;
+}
+export declare const HandleContent: React.MemoExoticComponent<({ children, extendedTooltip }: HandleContentProps) => JSX.Element>;

package/dist/types/extensions/react-flow/handles/HandleDefault.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { HandleProps as ReactFlowHandleProps } from "react-flow-renderer";
+import { HandleContentProps } from "./HandleContent";
+export interface HandleProps extends ReactFlowHandleProps {
+    data?: HandleContentProps;
+    tooltip?: string;
+    children?: JSX.Element | string;
+}
+export declare const HandleDefault: React.MemoExoticComponent<({ data, tooltip, children, ...handleProps }: HandleProps) => JSX.Element>;

package/dist/types/extensions/react-flow/index.d.ts

@@ -0,0 +1,18 @@
+export { NodeDefault } from "./nodes/NodeDefault";
+export { NodeContent } from "./nodes/NodeContent";
+export { NodeContentExtension } from "./nodes/NodeContentExtension";
+export { NodeTools } from "./nodes/NodeTools";
+export { nodeTypes } from "./nodes/nodeTypes";
+export { EdgeDefault } from "./edges/EdgeDefault";
+export { EdgeStep } from "./edges/EdgeStep";
+export { EdgeTools } from "./edges/EdgeTools";
+export { edgeTypes } from "./edges/edgeTypes";
+export { MiniMap } from "./minimap/MiniMap";
+export { minimapNodeClassName, minimapNodeColor } from "./minimap/utils";
+export type { NodeProps } from "./nodes/NodeDefault";
+export type { NodeContentProps } from "./nodes/NodeContent";
+export type { NodeContentExtensionProps } from "./nodes/NodeContentExtension";
+export type { NodeToolsProps } from "./nodes/NodeTools";
+export type { EdgeDefaultProps } from "./edges/EdgeDefault";
+export type { EdgeStepProps } from "./edges/EdgeStep";
+export type { MiniMapProps } from "./minimap/MiniMap";

package/dist/types/extensions/react-flow/minimap/MiniMap.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+import { MiniMapProps as ReactFlowMiniMapProps, OnLoadParams } from "react-flow-renderer";
+export interface MiniMapProps extends ReactFlowMiniMapProps {
+    flowInstance?: OnLoadParams;
+    enableNavigation?: boolean;
+}
+/** An improved mini-map for react-flow that supports navigation via the mini-map. */
+export declare const MiniMap: React.MemoExoticComponent<({ flowInstance, enableNavigation, maskColor, ...minimapProps }: MiniMapProps) => JSX.Element>;

package/dist/types/extensions/react-flow/minimap/utils.d.ts

@@ -0,0 +1,2 @@
+export declare const minimapNodeClassName: (node: any) => string;
+export declare const minimapNodeColor: (node: any) => any;

package/dist/types/extensions/react-flow/nodes/NodeContent.d.ts

@@ -0,0 +1,121 @@
+import React from "react";
+import { Position } from "react-flow-renderer";
+import { ValidIconName } from "../../../components/Icon/canonicalIconNames";
+import { HandleProps } from "./../handles/HandleDefault";
+import { NodeProps } from "./NodeDefault";
+declare type HighlightingState = "success" | "warning" | "danger" | "match" | "altmatch";
+export interface IHandleProps extends HandleProps {
+    category?: "configuration";
+}
+interface NodeContentData {
+    /**
+     * Name of icon that should be displayed before the node label.
+     * Must be a name from our list of canonical icon names.
+     */
+    iconName?: ValidIconName;
+    /**
+     * Valid and accessible URL or `data-uri` for an image that should be displayed before the node label.
+     */
+    depiction?: string;
+    /**
+     * Label that is displayed in the node header.
+     */
+    label: string;
+    /**
+     * Content element, displayed in the node body.
+     */
+    content?: React.ReactNode;
+    /**
+     * Content extension, displayed at the bottom side of a node.
+     */
+    contentExtension?: React.ReactNode;
+}
+export interface NodeContentProps<T> extends NodeContentData, React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Size of the node.
+     * If `minimalShape` is not set to `none`then the configured size definition is only used for the selected node state.
+     */
+    size?: "tiny" | "small" | "medium" | "large";
+    /**
+     * Defines if the node is initially displayed within a very small shape.
+     * If not set to `none` then the node is only displayed in normal size when it is selected.
+     */
+    minimalShape?: "none" | "circular" | "rectangular";
+    /**
+     * Set the type of used highlights to mark the node.
+     */
+    highlightedState?: HighlightingState | HighlightingState[];
+    /**
+     * Text used for tooltip used on icon and depiction.
+     */
+    typeLabel?: string;
+    /**
+     * If `executionButtons` content is included or not.
+     * It is displayed in the node header between label and menu.
+     */
+    showExecutionButtons?: boolean;
+    /**
+     * Set of defined buttons and icons that can be displayed.
+     */
+    executionButtons?: () => React.ReactNode;
+    /**
+     * Can be used for permanent action button or context menu.
+     * It is displayed at the node header right to the label.
+     */
+    menuButtons?: React.ReactNode;
+    /**
+     * Array of property definition objects for `Handle` components that need to be created for the node.
+     * @see https://reactflow.dev/docs/api/handle/
+     */
+    handles?: IHandleProps[];
+    /**
+     * Set the minimal number of handles on left or right side of the node to activate the recalculation of the minimal height of the node.
+     */
+    adaptHeightForHandleMinCount?: number;
+    /**
+     * Height per handle in px (without the unit) used for minimal height calculation of the node.
+     */
+    adaptSizeIncrement?: number;
+    /**
+     * Callback function to provide content for the tooltip on a node with a defined `minimalShape`.
+     * If you do not want a tooltip in this state you need to provide a callback that returns an empty value.
+     */
+    getMinimalTooltipData?: (node: NodeProps<T>) => NodeContentData;
+    /**
+     * Set if a handle is displayed even if it does not allow a connection to an edge.
+     */
+    showUnconnectableHandles?: boolean;
+    /**
+     * The node is displayed with some animated shadow for highlighting purposes.
+     */
+    animated?: boolean;
+    /** Additional data stored in the node. */
+    businessData?: T;
+    /**
+     * This property is only forwarded from the `NodeDefault` element.
+     * If set then it will be always overwritten internally.
+     */
+    targetPosition?: typeof Position[keyof typeof Position];
+    /**
+     * This property is only forwarded from the `NodeDefault` element.
+     * If set then it will be always overwritten internally.
+     */
+    sourcePosition?: typeof Position[keyof typeof Position];
+    /**
+     * This property is only forwarded from the `NodeDefault` element.
+     * If set then it will be always overwritten internally.
+     */
+    isConnectable?: boolean;
+    /**
+     * This property is only forwarded from the `NodeDefault` element.
+     * If set then it will be always overwritten internally.
+     */
+    selected?: boolean;
+}
+export declare const gethighlightedStateClasses: (state: any, baseClassName: any) => any;
+/**
+ * The `NodeContent` element manages the main view of how a node is displaying which content.
+ * This element cannot be used directly, all properties must be routed through the `data` property of an `elements` property item inside the `ReactFlow` container.
+ */
+export declare const NodeContent: ({ iconName, depiction, typeLabel, label, showExecutionButtons, executionButtons, menuButtons, content, contentExtension, size, minimalShape, highlightedState, handles, adaptHeightForHandleMinCount, adaptSizeIncrement, getMinimalTooltipData, style, showUnconnectableHandles, animated, targetPosition, sourcePosition, isConnectable, selected, businessData, ...otherProps }: NodeContentProps<any>) => JSX.Element;
+export {};

package/dist/types/extensions/react-flow/nodes/NodeContentExtension.d.ts

@@ -0,0 +1,30 @@
+import React from "react";
+export interface NodeContentExtensionProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Element is displayed in expanded state.
+     * If it has no `onToggle` handler property set then it is always expanded.
+     */
+    isExpanded?: boolean;
+    /**
+     * Click handler to manage the expanded state from outside the the element.
+     * This state is not managed automatically by the element itself.
+     */
+    onToggle?: (event: React.MouseEvent<HTMLElement>, isExpanded: boolean) => void;
+    /**
+     * Single element or aray of `IconButton` and `Button` elements.
+     * They will be displayed beside the closing button under the element content body.
+     */
+    actionButtons?: React.ReactNode | React.ReactNode[];
+    /**
+     * Tooltip text for expand button.
+     */
+    tooltipExpand?: string;
+    /**
+     * Tooltip text for expand button.
+     */
+    tooltipReduce?: string;
+}
+/**
+ * Displays an content area that can be attached to `NodeContent` elements.
+ */
+export declare const NodeContentExtension: ({ children, isExpanded, onToggle, actionButtons, tooltipExpand, tooltipReduce, ...otherProps }: NodeContentExtensionProps) => JSX.Element;

package/dist/types/extensions/react-flow/nodes/NodeDefault.d.ts

@@ -0,0 +1,16 @@
+import React from "react";
+import { NodeProps as ReactFlowNodeProps } from "react-flow-renderer";
+import { NodeContentProps } from "./NodeContent";
+export interface NodeProps<T> extends ReactFlowNodeProps {
+    /**
+     * Contains all properties for our implementation of the React-Flow node.
+     * For details pls see the `NodeContent` element documentation.
+     */
+    data: NodeContentProps<T>;
+}
+/**
+ * The `NodeDefault` element manages the display of React-Flow nodes.
+ * This element cannot be used directly, it must be connected via a `nodeTypes` definition and all properties need to be routed through the `elements` property items inside the `ReactFlow` container.
+ * @see https://reactflow.dev/docs/api/nodes/
+ */
+export declare const NodeDefault: React.MemoExoticComponent<(node: NodeProps<any>) => JSX.Element>;

package/dist/types/extensions/react-flow/nodes/NodeTools.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import { IPopoverProps as IBlueprintPopoverProps } from "@blueprintjs/core";
+export interface NodeToolsProps extends IBlueprintPopoverProps {
+    children: string | JSX.Element;
+    togglerElement?: string | JSX.Element;
+    togglerText?: string;
+    menuButtonDataTestId?: string;
+}
+export declare const NodeTools: React.MemoExoticComponent<({ children, togglerElement, togglerText, menuButtonDataTestId, ...otherOverlayProps }: NodeToolsProps) => JSX.Element>;

package/dist/types/extensions/react-flow/nodes/nodeTypes.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+export declare const nodeTypes: {
+    default: import("react").MemoExoticComponent<(node: import("./NodeDefault").NodeProps<any>) => JSX.Element>;
+    graphNode: import("react").MemoExoticComponent<(node: import("./NodeDefault").NodeProps<any>) => JSX.Element>;
+    classNode: import("react").MemoExoticComponent<(node: import("./NodeDefault").NodeProps<any>) => JSX.Element>;
+    instanceNode: import("react").MemoExoticComponent<(node: import("./NodeDefault").NodeProps<any>) => JSX.Element>;
+    propertyNode: import("react").MemoExoticComponent<(node: import("./NodeDefault").NodeProps<any>) => JSX.Element>;
+    datasetNode: import("react").MemoExoticComponent<(node: import("./NodeDefault").NodeProps<any>) => JSX.Element>;
+    linkingNode: import("react").MemoExoticComponent<(node: import("./NodeDefault").NodeProps<any>) => JSX.Element>;
+    transformNode: import("react").MemoExoticComponent<(node: import("./NodeDefault").NodeProps<any>) => JSX.Element>;
+    taskNode: import("react").MemoExoticComponent<(node: import("./NodeDefault").NodeProps<any>) => JSX.Element>;
+    workflowNode: import("react").MemoExoticComponent<(node: import("./NodeDefault").NodeProps<any>) => JSX.Element>;
+};