components/flow/types#

optional defaultNodeSet?: string;

optional edgeTypes?: Record<string, FC<any>>;

nodeSets: FlowNodeSet<string, NodeTypeToAttrs<string>>[];

optional onNodeError?: (nodeId, error) => void;

optional onPipelineRun?: (ir) => void;

activeNodeSet: string;

configuration: FlowConfiguration;

errorMap: Record<string, string>;

optional readOnly?: boolean;

optional registerSetNodeAttr?: (fn) => void;

rerun: () => void;

selectedNode: any;

setActiveNodeSet: (nodeSet) => void;

optional setNodeAttr?: (nodeId, attr, value) => void;

setRerun: (fn) => void;

setSelectedNode: (node) => void;

statusMap: Record<string, NodeExecutionStatus>;

[key: string]: any

attrs: T;

id: string;

label: string;

optional category?: string;

component: FlowNodeComponent<T, AttrsT>;

optional dynamicInputs?: (attrs) => Record<string, React.ReactNode>;

optional icon?: any;

label: (t) => string;

optional pluginId?: string;

optional requiredCapabilities?: string[];

optional requiredOps?: string[];

optional settingsComponent?: FlowNodeSettingsComponent<T, AttrsT>;

signature: 
  | FlowNodeSignature<AttrsT>
  | DynamicFlowNodeSignature<AttrsT>;

optional singleton?: boolean;

type: T;

optional categories?: Record<string, T[]>;

optional categoryColors?: Record<string, string>;

optional categoryIcons?: Record<string, SvgIconComponent>;

optional customParser?: (nodes, edges) => any;

optional customValidation?: (nodes, edges) => boolean;

optional dtypeColorMap?: Record<string, {
  bg: string;
  handle: string;
  text: string;
}>;

optional irTransformer?: (ir) => any;

name: string;

nodes: { [K in string]: FlowNodeDefinition<K, AttrsMap[K]> };

data: FlowNodeData<AttrsT>;

getAttr: <K>(attr) => AttrsT[K];

id: string;

setAttr: <K>(attr, value) => void;

t: TFunction<any, any>;

type: T;

type BaseDType = string;

type DType = BaseDType | `${BaseDType}|${BaseDType}` | string;

type DynamicFlowNodeSignature<T> = (attrs) => FlowNodeSignature<T>;

type DynamicInput = {
  component: React.ReactNode;
  condition?: (attrs) => boolean;
  id: string;
};

component: React.ReactNode;

optional condition?: (attrs) => boolean;

id: string;

type FlowArgument = {
  allowMultiple?: boolean;
  dtype: DType;
  id: string;
  label: (t) => string;
  optional?: boolean;
};

optional allowMultiple?: boolean;

dtype: DType;

id: string;

label: (t) => string;

optional optional?: boolean;

type FlowAttribute<V> = {
  FlowAttribute: V;
  label: (t) => string;
  options?: V[];
};

FlowAttribute: V;

label: (t) => string;

optional options?: V[];

type FlowAttributeDefinition<T> = { [K in keyof T]: FlowAttribute<T[K]> };

type FlowNode<T, AttrsT> = Node<FlowNodeData<AttrsT>, T>;

type FlowNodeComponent<T, AttrsT> = React.FC<FlowNodeProps<T, AttrsT>>;

type FlowNodeProps<T, AttrsT> = NodeProps<FlowNode<T, AttrsT>>;

type FlowNodeSettingsComponent<T, AttrsT> = React.FC<FlowNodeSettingsInfo<T, AttrsT>>;

type FlowNodeSignature<T> = {
  attrs: FlowAttributeDefinition<T>;
  in: FlowArgument[];
  out: FlowArgument[];
};

attrs: FlowAttributeDefinition<T>;

in: FlowArgument[];

out: FlowArgument[];

type NodeExecutionStatus = "pending" | "executing" | "completed" | "error";

type NodeTypeToAttrs<T> = Record<T, Record<string, any>>;