hise-flow-graphs 1.1.19 → 1.1.21

package/dist/@types/CertificateTypes.d.ts

@@ -0,0 +1,64 @@
+import { Edge, Node } from 'reactflow';
+import { StringMap } from './GeneralTypes';
+export interface Certificate {
+    id: string;
+    isExecutable: boolean;
+    vertices: Array<string>;
+    edges: object;
+    generatedLabels: StringMap;
+    customLabels: StringMap;
+    serviceLabels: StringMap;
+    schemes: StringMap;
+    metadata: {
+        [key: string]: Metadata;
+    };
+    restrictedAssets: {
+        [vertex: string]: RestrictedAssetObject;
+    };
+    subgraphs: {
+        [key: string]: {
+            edges: {
+                [key: string]: Array<string>;
+            };
+            vertices: {
+                [key: string]: null;
+            };
+        };
+    };
+}
+export interface RestrictedAssetObject {
+    restrictionInstructions: string;
+    restrictionNotes: string;
+}
+export type MetadataMap = {
+    [key: string]: any;
+};
+export declare enum MetadataType {
+    labData = "labData",
+    surveyData = "surveyData",
+    demographicsData = "demographicsData",
+    emrData = "emrData"
+}
+export type Metadata = {
+    [key in MetadataType]?: MetadataMap;
+};
+export type Replica = {
+    matches: StringMap;
+    replicaOperations: {
+        [key: string]: ReplicaPipelineOperation;
+    };
+};
+export type ReplicaPipelineOperation = {
+    failureMessage: string;
+    operationStatus: string;
+};
+export type NodeLayers = {
+    previous: {
+        nodes: Array<Node>;
+        edges: Array<Edge>;
+    };
+    current: {
+        nodes: Array<Node>;
+        edges: Array<Edge>;
+    };
+};

package/dist/@types/GeneralTypes.d.ts

@@ -0,0 +1,35 @@
+export type StringMap = {
+    [key: string]: any;
+};
+export type Response = {
+    status: Number;
+    data: any;
+};
+export type Error = {
+    Message: string;
+    Status: Number;
+};
+export type Pipeline = {
+    id: string;
+    pipelineType: string;
+    status: PipelineStatus;
+    samplesComplete: object;
+    sampleCount: Number;
+    mainProcessID: string;
+    projectGuid: string;
+};
+export declare enum PipelineStatus {
+    Completed = "Completed",
+    Failure = "Failure",
+    Running = "Running",
+    Processing = "Processing",
+    Initiated = "Initiated"
+}
+export type IDE = {
+    name: string;
+    state: IDEState;
+};
+export declare enum IDEState {
+    ACTIVE = "ACTIVE",
+    STOPPED = "STOPPED"
+}

package/dist/components/Certificates/CertificateGraph/LayerBackButton.d.ts

@@ -0,0 +1,2 @@
+declare const LayerBackButton: () => import("react/jsx-runtime").JSX.Element | null;
+export default LayerBackButton;

package/dist/components/Certificates/CertificateGraph/NodeAttributes.d.ts

@@ -0,0 +1,9 @@
+export declare const Description: ({ label, description }: {
+    label: string;
+    description: any;
+}) => import("react/jsx-runtime").JSX.Element | null;
+export declare const Label: ({ label, description, link }: {
+    label: string;
+    description?: any | null;
+    link?: string | null;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/components/Certificates/CertificateGraph/helpers.d.ts

@@ -0,0 +1,31 @@
+import { CSSProperties } from 'react';
+import { Node, Edge } from 'reactflow';
+import { StringMap } from '../../../@types/GeneralTypes';
+import { Certificate } from '../../../@types/CertificateTypes';
+export declare const getNodesAndEdges: (vertices: Certificate["vertices"], edges: Certificate["edges"], restrictedAssets: Certificate["restrictedAssets"], type: string, data?: {
+    [key: string]: Function;
+} | undefined) => {
+    nodes: Node[];
+    edges: Edge[];
+};
+export declare const getNodes: (vertices: Certificate["vertices"], restrictedAssets: Certificate["restrictedAssets"], type: string, data: {
+    [key: string]: Function;
+} | undefined) => Node[];
+export declare const getEdges: (edges: Certificate["edges"]) => never[];
+export declare const getLayoutedElements: (nodes: Array<Node>, edges: Array<Edge>, direction?: string) => {
+    nodes: Node[];
+    edges: Edge[];
+};
+export declare const getStyle: (type: string) => CSSProperties;
+export declare const getSchemes: (label: string, vertex: string, labels: Certificate["serviceLabels"], schemes: Certificate["schemes"]) => {
+    [key: string]: object;
+};
+export declare const getNodeLabel: (type: string, desc: any) => string | import("react/jsx-runtime").JSX.Element | null;
+export declare const getNodeDescription: (type: string, desc: any) => any;
+export declare const getLabelLink: (type: string, guid: string, isExecutable: "true" | "false") => string | null;
+export declare const getKey: (key: string, scheme: {
+    [key: string]: StringMap;
+}, tab: string) => any;
+export declare const getValue: (key: string, value: any, scheme: {
+    [key: string]: StringMap;
+}, tab: string) => any;

package/dist/components/Certificates/CertificateGraph/index.d.ts

@@ -0,0 +1,16 @@
+import { Node, Edge } from 'reactflow';
+import { Certificate, Replica } from '../../../@types/CertificateTypes';
+import 'react-toastify/dist/ReactToastify.css';
+import 'reactflow/dist/style.css';
+import './style.css';
+declare const CertificateGraph: ({ type, certificate, replica, graph, children }: {
+    type: string;
+    certificate: Certificate;
+    graph: {
+        nodes: Array<Node>;
+        edges: Array<Edge>;
+    };
+    replica?: Replica;
+    children?: any;
+}) => import("react/jsx-runtime").JSX.Element;
+export default CertificateGraph;

package/dist/components/Certificates/EditCertificate/EditNode.d.ts

@@ -0,0 +1,3 @@
+import { NodeProps } from 'reactflow';
+declare const EditNode: (props: NodeProps) => import("react/jsx-runtime").JSX.Element;
+export default EditNode;

package/dist/components/Certificates/EditCertificate/EditNodeModal.d.ts

@@ -0,0 +1,18 @@
+import { NodeProps } from 'reactflow';
+export declare const EditNodeModalBtn: ({ node }: {
+    node: NodeProps;
+}) => import("react/jsx-runtime").JSX.Element;
+declare const EditNodeModal: ({ isOpen, loading, toggle, handleUpdate, refresh, ingestUiNode }: {
+    isOpen: boolean;
+    loading: boolean;
+    toggle: Function;
+    handleUpdate: Function;
+    refresh: Function;
+    ingestUiNode?: {
+        node: {
+            id: string;
+        };
+        certificate: any;
+    };
+}) => import("react/jsx-runtime").JSX.Element | null;
+export default EditNodeModal;

package/dist/components/Certificates/EditCertificate/MaskMetadataModal/EMRMaskingTables.d.ts

@@ -0,0 +1,10 @@
+import { Metadata, MetadataType } from '../../../../@types/CertificateTypes';
+declare const EMRMaskingTables: ({ type, metadata, setMetadata, ingestUiProps }: {
+    type: MetadataType;
+    metadata: Metadata;
+    setMetadata: Function;
+    ingestUiProps?: {
+        schemes: any;
+    };
+}) => import("react/jsx-runtime").JSX.Element | null;
+export default EMRMaskingTables;

package/dist/components/Certificates/EditCertificate/MaskMetadataModal/MaskMetadataTable.d.ts

@@ -0,0 +1,20 @@
+import { Metadata, MetadataType } from '../../../../@types/CertificateTypes';
+declare const MaskMetadataTable: {
+    ({ type, metadata, setMetadata, emrEntry, emrIndex, ingestUiProps }: {
+        type: MetadataType;
+        metadata: Metadata;
+        setMetadata: Function;
+        emrEntry: {
+            [key: string]: any;
+        };
+        emrIndex: number;
+        ingestUiProps?: {
+            schemes: any;
+        };
+    }): import("react/jsx-runtime").JSX.Element;
+    defaultProps: {
+        emrEntry: null;
+        emrIndex: null;
+    };
+};
+export default MaskMetadataTable;

package/dist/components/Certificates/EditCertificate/MaskMetadataModal/helpers.d.ts

@@ -0,0 +1,7 @@
+import { Metadata } from '../../../../@types/CertificateTypes';
+export declare const maskRow: (variable: string, currMetadata: {
+    [key: string]: any;
+}, dataType: string, update: Function) => void;
+export declare const maskEMRRow: (variable: string, currMetadata: Metadata, update: Function, emrEntry: {
+    [key: string]: any;
+}, emrIndex: number) => void;

package/dist/components/Certificates/EditCertificate/MaskMetadataModal/index.d.ts

@@ -0,0 +1,21 @@
+import { NodeProps } from "reactflow";
+export declare const labels: {
+    [key: string]: string;
+};
+export declare const MaskMetadataButton: ({ node }: {
+    node: NodeProps;
+}) => import("react/jsx-runtime").JSX.Element | null;
+declare const MaskMetadataModal: ({ isOpen, loading, toggle, handleUpdate, refresh, ingestUiNode, }: {
+    isOpen: boolean;
+    loading: boolean;
+    toggle: Function;
+    handleUpdate: Function;
+    refresh: Function;
+    ingestUiNode?: {
+        node: {
+            id: string;
+        };
+        certificate: any;
+    };
+}) => import("react/jsx-runtime").JSX.Element;
+export default MaskMetadataModal;

package/dist/components/Certificates/EditCertificate/helpers.d.ts

@@ -0,0 +1,6 @@
+export declare const getFormControls: (label: string, description: object) => ({
+    type: string;
+    key: string;
+    label: string;
+    invalid: (d: string) => boolean;
+} | null)[] | null;

package/dist/components/Certificates/EditCertificate/index.d.ts

@@ -0,0 +1,8 @@
+import { Certificate } from '../../../@types/CertificateTypes';
+declare const EditCertificate: ({ certificate, loading, handleUpdate, refresh }: {
+    certificate: Certificate;
+    loading: boolean;
+    handleUpdate: Function;
+    refresh: Function;
+}) => import("react/jsx-runtime").JSX.Element;
+export default EditCertificate;

package/dist/components/Certificates/FileLayerNode/CopyFileLayer.d.ts

@@ -0,0 +1,24 @@
+type CopyFileLayerNodeButton = {
+    vertexId: string;
+    certificateId: string;
+    type: string;
+    isNodeHover: boolean;
+    toggle: Function;
+};
+type CopyFileLayerSubgraphButton = {
+    vertexId: string;
+    certificateId: string;
+    type: string;
+    refresh: Function;
+};
+type CopyFileLayerModalProps = {
+    vertexId: string;
+    certificateId: string;
+    refresh: Function;
+    isOpen: boolean;
+    toggle: Function;
+};
+declare const CopyFileLayerNodeButton: (props: CopyFileLayerNodeButton) => import("react/jsx-runtime").JSX.Element | null;
+export declare const CopyFileLayerSubgraphButton: (props: CopyFileLayerSubgraphButton) => import("react/jsx-runtime").JSX.Element | null;
+export declare const CopyFileLayerModal: ({ vertexId, certificateId, refresh, isOpen, toggle }: CopyFileLayerModalProps) => import("react/jsx-runtime").JSX.Element;
+export default CopyFileLayerNodeButton;

package/dist/components/Certificates/FileLayerNode/index.d.ts

@@ -0,0 +1,3 @@
+import { NodeProps } from 'reactflow';
+declare const FileLayerNode: (props: NodeProps) => import("react/jsx-runtime").JSX.Element;
+export default FileLayerNode;

package/dist/components/Certificates/ReadCertificate/MetadataModal/MetadataTable.d.ts

@@ -0,0 +1,10 @@
+declare const MetadataTable: ({ metadata, scheme, activeTab }: {
+    metadata: {
+        [key: string]: any;
+    };
+    scheme: {
+        [key: string]: any;
+    };
+    activeTab: string;
+}) => import("react/jsx-runtime").JSX.Element;
+export default MetadataTable;

package/dist/components/Certificates/ReadCertificate/MetadataModal/helpers.d.ts

@@ -0,0 +1,8 @@
+import { Metadata } from "../../../../@types/CertificateTypes";
+export declare const getHeader: (label: string, desc: {
+    [key: string]: string;
+}) => string;
+export declare const getTabs: (metadata: Metadata) => string[];
+export declare const hasMetadata: (metadata: {
+    [key: string]: Metadata;
+}, nodeId: string) => boolean;

package/dist/components/Certificates/ReadCertificate/MetadataModal/index.d.ts

@@ -0,0 +1,10 @@
+import { NodeProps } from 'reactflow';
+export declare const MetadataButton: ({ label, node }: {
+    label: string;
+    node: NodeProps;
+}) => import("react/jsx-runtime").JSX.Element | null;
+declare const MetadataModal: ({ isOpen, toggle }: {
+    isOpen: boolean;
+    toggle: Function;
+}) => import("react/jsx-runtime").JSX.Element;
+export default MetadataModal;

package/dist/components/Certificates/ReadCertificate/ReadNode.d.ts

@@ -0,0 +1,3 @@
+import { NodeProps } from 'reactflow';
+declare const ReadNode: (props: NodeProps) => import("react/jsx-runtime").JSX.Element;
+export default ReadNode;

package/dist/components/Certificates/ReadCertificate/index.d.ts

@@ -0,0 +1,5 @@
+import { Certificate } from '../../../@types/CertificateTypes';
+declare const ReadCertificate: ({ certificate }: {
+    certificate: Certificate;
+}) => import("react/jsx-runtime").JSX.Element;
+export default ReadCertificate;

package/dist/components/Certificates/ReviewCertificate/RestrictNode/index.d.ts

@@ -0,0 +1,10 @@
+import 'react-quill/dist/quill.snow.css';
+import './style.css';
+type ModalProps = {
+    isOpen: boolean;
+    onClose: Function;
+    refresh: Function;
+    handleUpdate: Function;
+};
+declare const RestrictNodeModal: React.FC<ModalProps>;
+export default RestrictNodeModal;

package/dist/components/Certificates/ReviewCertificate/ReviewNode.d.ts

@@ -0,0 +1,3 @@
+import { NodeProps } from 'reactflow';
+declare const ReviewNode: (props: NodeProps) => import("react/jsx-runtime").JSX.Element;
+export default ReviewNode;

package/dist/components/Certificates/ReviewCertificate/ReviewNodes/index.d.ts

@@ -0,0 +1,22 @@
+import { NodeProps } from 'reactflow';
+export declare const ReviewBtn: ({ node }: {
+    node: NodeProps;
+}) => import("react/jsx-runtime").JSX.Element | null;
+type ModalProps = {
+    isOpen: boolean;
+    loading: boolean;
+    form: object;
+    setForm: Function;
+    getSubmissionBody: Function;
+    clear: Function;
+    toggle: Function;
+    handleUpdate: Function;
+    refresh: Function;
+};
+declare const ReviewNodesModal: {
+    (props: ModalProps): import("react/jsx-runtime").JSX.Element;
+    defaultProps: {
+        children: null;
+    };
+};
+export default ReviewNodesModal;

package/dist/components/Certificates/ReviewCertificate/helpers.d.ts

@@ -0,0 +1,14 @@
+import { CSSProperties } from 'react';
+export declare const getStyle: (type: string, isAssetRestricted: boolean) => CSSProperties;
+export declare const getFormControls: (key?: "restrictionNotes" | undefined) => {
+    type: string;
+    key: string;
+    label: string;
+    invalid: (d: any) => boolean;
+} | {
+    type: string;
+    key: string;
+    label: string;
+    invalid: (d: any) => boolean;
+}[];
+export declare const getFilteredRestrictedAssets: (assetBeingRemoved: string, restrictedAssets: any) => any;

package/dist/components/Certificates/ReviewCertificate/index.d.ts

@@ -0,0 +1,7 @@
+import { Certificate } from '../../../@types/CertificateTypes';
+declare const ReviewCertificate: ({ certificate, handleUpdate, refresh }: {
+    certificate: Certificate;
+    handleUpdate: Function;
+    refresh: Function;
+}) => import("react/jsx-runtime").JSX.Element;
+export default ReviewCertificate;

package/dist/components/Certificates/WalkingGraph/ActionsMenu.d.ts

@@ -0,0 +1,4 @@
+declare const ActionsMenu: ({ setIsLayersItemModalOpen }: {
+    setIsLayersItemModalOpen: Function;
+}) => import("react/jsx-runtime").JSX.Element | null;
+export default ActionsMenu;

package/dist/components/Certificates/WalkingGraph/LayerItemsModal.d.ts

@@ -0,0 +1,5 @@
+declare const LayerItemsModal: ({ isOpen, setIsOpen }: {
+    isOpen: boolean;
+    setIsOpen: Function;
+}) => import("react/jsx-runtime").JSX.Element;
+export default LayerItemsModal;

package/dist/components/Certificates/WalkingGraph/WalkingNode.d.ts

@@ -0,0 +1,3 @@
+import { NodeProps } from 'reactflow';
+declare const WalkingNode: ({ id }: NodeProps) => import("react/jsx-runtime").JSX.Element;
+export default WalkingNode;

package/dist/components/Certificates/WalkingGraph/helpers.d.ts

@@ -0,0 +1,11 @@
+import { Edge, Node } from "reactflow";
+import { Certificate } from "../../../@types/CertificateTypes";
+export declare const nodeWidth = 250;
+export declare const nodeHeight = 120;
+export declare const getWalkingNodesAndEdges: (nodes: Array<Node>, edges: Array<Edge>, direction?: string) => {
+    nodes: Node[];
+    edges: Edge[];
+};
+export declare const getUpdatedNodes: (currentNodes: Array<Node>, newNodes: Certificate["vertices"], certificate: Certificate, isUpdate?: boolean) => Node[];
+export declare const getUpdatedEdges: (currentEdges: Array<Edge>, newEdges: Certificate["edges"]) => Edge[];
+export declare const getLink: (id: Node["id"]) => string;

package/dist/components/Certificates/WalkingGraph/index.d.ts

@@ -0,0 +1,5 @@
+import { Certificate } from '../../../@types/CertificateTypes';
+declare const WalkingGraph: ({ certificate }: {
+    certificate: Certificate;
+}) => import("react/jsx-runtime").JSX.Element;
+export default WalkingGraph;

package/dist/components/Certificates/WorkspaceCertificate/ReplicaIDENode/helpers.d.ts

@@ -0,0 +1,2 @@
+export declare const startIDE: () => void;
+export declare const stopIDE: () => void;

package/dist/components/Certificates/WorkspaceCertificate/ReplicaIDENode/index.d.ts

@@ -0,0 +1,3 @@
+import { NodeProps } from 'reactflow';
+declare const ReplicaIDENode: (props: NodeProps) => import("react/jsx-runtime").JSX.Element;
+export default ReplicaIDENode;

package/dist/components/Certificates/WorkspaceCertificate/ReplicaPipelineNode/index.d.ts

@@ -0,0 +1,15 @@
+import { NodeProps } from 'reactflow';
+import { Pipeline, PipelineStatus } from '../../../../@types/GeneralTypes';
+import { ReplicaPipelineOperation } from '../../../../@types/CertificateTypes';
+export declare const Status: ({ status, replicaPipelineOperation, pipelineId }: {
+    status: PipelineStatus;
+    replicaPipelineOperation: ReplicaPipelineOperation;
+    pipelineId: string;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const ReplicaPipelineInfo: ({ pipeline, replicaPipelineOperation, refresh }: {
+    pipeline: Pipeline | null;
+    replicaPipelineOperation: ReplicaPipelineOperation;
+    refresh: Function;
+}) => import("react/jsx-runtime").JSX.Element | null;
+declare const ReplicaPipelineNode: (props: NodeProps) => import("react/jsx-runtime").JSX.Element;
+export default ReplicaPipelineNode;

package/dist/components/Certificates/WorkspaceCertificate/RestrictedNode/index.d.ts

@@ -0,0 +1,7 @@
+import { NodeProps } from 'reactflow';
+import { RestrictedAssetObject } from '../../../../@types/CertificateTypes';
+interface RestrictedNode extends NodeProps {
+    restrictedAsset: RestrictedAssetObject;
+}
+declare const RestrictedNode: (props: RestrictedNode) => import("react/jsx-runtime").JSX.Element;
+export default RestrictedNode;

package/dist/components/Certificates/WorkspaceCertificate/WorkspaceFileNode/helpers.d.ts

@@ -0,0 +1 @@
+export declare const copyFile: (vertexId: string, certId: string) => Promise<Response>;

package/dist/components/Certificates/WorkspaceCertificate/WorkspaceFileNode/index.d.ts

@@ -0,0 +1,3 @@
+import { NodeProps } from 'reactflow';
+declare const WorkspaceFileNode: (props: NodeProps) => import("react/jsx-runtime").JSX.Element;
+export default WorkspaceFileNode;

package/dist/components/Certificates/WorkspaceCertificate/WorkspaceIDENode/IDEModal.d.ts

@@ -0,0 +1,7 @@
+declare const IDEModal: ({ loading, isOpen, toggle, onStartIDE }: {
+    loading: boolean;
+    isOpen: boolean;
+    toggle: Function;
+    onStartIDE: Function;
+}) => import("react/jsx-runtime").JSX.Element;
+export default IDEModal;

package/dist/components/Certificates/WorkspaceCertificate/WorkspaceIDENode/helpers.d.ts

@@ -0,0 +1,3 @@
+import { Replica } from "../../../../@types/CertificateTypes";
+export declare const runIDE: (vertexId: string, certId: string) => Promise<Response>;
+export declare const startIDE: (vertexId: string, certificateId: string, edges: object, matches: Replica["matches"], refresh: Function, toggleModal: Function) => Promise<void>;

package/dist/components/Certificates/WorkspaceCertificate/WorkspaceIDENode/index.d.ts

@@ -0,0 +1,3 @@
+import { NodeProps } from 'reactflow';
+declare const WorkspaceIDENode: (props: NodeProps) => import("react/jsx-runtime").JSX.Element;
+export default WorkspaceIDENode;

package/dist/components/Certificates/WorkspaceCertificate/WorkspaceNode/index.d.ts

@@ -0,0 +1,8 @@
+import { Node } from 'reactflow';
+declare const WorkspaceNode: (props: {
+    id: string;
+    data: Node["data"];
+    modal: React.ReactNode;
+    toggle: Function;
+}) => import("react/jsx-runtime").JSX.Element;
+export default WorkspaceNode;

package/dist/components/Certificates/WorkspaceCertificate/WorkspacePipelineNode/PipelineModal.d.ts

@@ -0,0 +1,7 @@
+declare const PipelineModal: ({ loading, isOpen, toggle, onStartPipeline }: {
+    loading: boolean;
+    isOpen: boolean;
+    toggle: Function;
+    onStartPipeline: Function;
+}) => import("react/jsx-runtime").JSX.Element;
+export default PipelineModal;

package/dist/components/Certificates/WorkspaceCertificate/WorkspacePipelineNode/helpers.d.ts

@@ -0,0 +1,3 @@
+import { Replica } from "../../../../@types/CertificateTypes";
+export declare const runPipeline: (vertexId: string, certId: string) => Promise<Response>;
+export declare const startPipeline: (vertexId: string, certificateId: string, edges: object, matches: Replica["matches"], refresh: Function, toggleModal: Function) => Promise<void>;

package/dist/components/Certificates/WorkspaceCertificate/WorkspacePipelineNode/index.d.ts

@@ -0,0 +1,3 @@
+import { NodeProps } from 'reactflow';
+declare const WorkspacePipelineNode: (props: NodeProps) => import("react/jsx-runtime").JSX.Element;
+export default WorkspacePipelineNode;

package/dist/components/Certificates/WorkspaceCertificate/helpers.d.ts

@@ -0,0 +1,10 @@
+import { Edge, Node } from 'reactflow';
+import { Certificate, Replica } from '../../../@types/CertificateTypes';
+export declare const getWorkspaceNodesAndEdges: (vertices: Certificate["vertices"], edges: Certificate["edges"], replica: Replica, data: {
+    [key: string]: Node["data"];
+}) => {
+    nodes: Node[];
+    edges: Edge[];
+};
+export declare const findInputFiles: (vertexId: string, edges: object, matches: Replica["matches"]) => Promise<string[]>;
+export declare const copyInputFiles: (files: Array<string>, certId: string) => Promise<Response[]>;

package/dist/components/Certificates/WorkspaceCertificate/index.d.ts

@@ -0,0 +1,8 @@
+import { Certificate, Replica } from '../../../@types/CertificateTypes';
+import './style.css';
+declare const WorkspaceCertificate: ({ certificate, replica, refresh }: {
+    certificate: Certificate;
+    replica: Replica;
+    refresh: Function;
+}) => import("react/jsx-runtime").JSX.Element | undefined;
+export default WorkspaceCertificate;

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+import ReadCertificate from './components/Certificates/ReadCertificate/index';
+import EditCertificate from './components/Certificates/EditCertificate/index';
+import ReviewCertificate from './components/Certificates/ReviewCertificate/index';
+import WorkspaceCertificate from './components/Certificates/WorkspaceCertificate/index';
+import WalkingGraph from './components/Certificates/WalkingGraph';
+import getCertificateBody from './utils/getCertificateBody';
+import EditNodeModal from './components/Certificates/EditCertificate/EditNodeModal';
+import MaskMetadataModal from './components/Certificates/EditCertificate/MaskMetadataModal/index';
+import PipelineModal from './components/Certificates/WorkspaceCertificate/WorkspacePipelineNode/PipelineModal';
+import IDEModal from './components/Certificates/WorkspaceCertificate/WorkspaceIDENode/IDEModal';
+import { getSchemes } from './components/Certificates/CertificateGraph/helpers';
+import { startPipeline } from './components/Certificates/WorkspaceCertificate/WorkspacePipelineNode/helpers';
+import { startIDE } from './components/Certificates/WorkspaceCertificate/WorkspaceIDENode/helpers';
+import { ReplicaPipelineInfo } from './components/Certificates/WorkspaceCertificate/ReplicaPipelineNode';
+declare const testComponent: () => void;
+export { ReadCertificate, EditCertificate, ReviewCertificate, WorkspaceCertificate, WalkingGraph, getCertificateBody, EditNodeModal, MaskMetadataModal, getSchemes, startPipeline, startIDE, PipelineModal, IDEModal, ReplicaPipelineInfo, testComponent };