lean4monaco 1.0.2 → 1.0.4

package/dist/monaco-lean4/lean4-infoview/src/index.d.ts

@@ -0,0 +1,16 @@
+import { MessageData } from '@leanprover/infoview-api';
+export * from '@leanprover/infoview-api';
+export { EditorContext, EnvPosContext, VersionContext } from './infoview/contexts';
+export { EditorConnection } from './infoview/editorConnection';
+export { GoalLocation, GoalsLocation, LocationsContext } from './infoview/goalLocation';
+export { InteractiveCode, InteractiveCodeProps } from './infoview/interactiveCode';
+export { renderInfoview } from './infoview/main';
+export { RpcContext, useRpcSession } from './infoview/rpcSessions';
+export { ServerVersion } from './infoview/serverVersion';
+export { DynamicComponent, DynamicComponentProps, PanelWidgetProps, importWidgetModule } from './infoview/userWidget';
+export { DocumentPosition, mapRpcError, useAsync, useAsyncPersistent, useAsyncWithTrigger, useClientNotificationEffect, useClientNotificationState, useEvent, useEventResult, useServerNotificationEffect, useServerNotificationState, } from './infoview/util';
+export { MessageData };
+/** Display the given message data as interactive, pretty-printed text. */
+export declare function InteractiveMessageData({ msg }: {
+    msg: MessageData;
+}): any;

package/dist/monaco-lean4/lean4-infoview/src/index.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { InteractiveDiagnostics_msgToInteractive } from '@leanprover/infoview-api';
+import { useRpcSession } from './infoview/rpcSessions';
+import { InteractiveMessage } from './infoview/traceExplorer';
+import { mapRpcError, useAsync } from './infoview/util';
+export * from '@leanprover/infoview-api';
+export { EditorContext, EnvPosContext, VersionContext } from './infoview/contexts';
+export { EditorConnection } from './infoview/editorConnection';
+export { GoalLocation, GoalsLocation, LocationsContext } from './infoview/goalLocation';
+export { InteractiveCode } from './infoview/interactiveCode';
+export { renderInfoview } from './infoview/main';
+export { RpcContext, useRpcSession } from './infoview/rpcSessions';
+export { ServerVersion } from './infoview/serverVersion';
+export { DynamicComponent, importWidgetModule } from './infoview/userWidget';
+export { DocumentPosition, mapRpcError, useAsync, useAsyncPersistent, useAsyncWithTrigger, useClientNotificationEffect, useClientNotificationState, useEvent, useEventResult, useServerNotificationEffect, useServerNotificationState, } from './infoview/util';
+/** Display the given message data as interactive, pretty-printed text. */
+export function InteractiveMessageData({ msg }) {
+    const rs = useRpcSession();
+    const interactive = useAsync(() => InteractiveDiagnostics_msgToInteractive(rs, msg, 0), [rs, msg]);
+    if (interactive.state === 'resolved') {
+        return _jsx(InteractiveMessage, { fmt: interactive.value });
+    }
+    else if (interactive.state === 'loading') {
+        return _jsx(_Fragment, { children: "..." });
+    }
+    else {
+        return (_jsxs("div", { children: ["Failed to display message:", _jsx("span", { children: mapRpcError(interactive.error).message })] }));
+    }
+}

package/dist/monaco-lean4/lean4-infoview/src/infoview/collapsing.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+/** Returns `[node, isVisible]`. Attach `node` to the dom element you care about as `<div ref={node}>...</div>` and
+ * `isVisible` will change depending on whether the node is visible in the viewport or not. */
+export declare function useIsVisible(): [(element: HTMLElement) => void, boolean];
+interface DetailsProps {
+    initiallyOpen?: boolean;
+    children: [React.ReactNode, ...React.ReactNode[]];
+    setOpenRef?: (_: React.Dispatch<React.SetStateAction<boolean>>) => void;
+}
+/** Like `<details>` but can be programatically revealed using `setOpenRef`. */
+export declare function Details({ initiallyOpen, children: [summary, ...children], setOpenRef }: DetailsProps): JSX.Element;
+export {};

package/dist/monaco-lean4/lean4-infoview/src/infoview/collapsing.js

@@ -0,0 +1,37 @@
+import { jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from 'react';
+/** Returns `[node, isVisible]`. Attach `node` to the dom element you care about as `<div ref={node}>...</div>` and
+ * `isVisible` will change depending on whether the node is visible in the viewport or not. */
+// NOTE: Unused.
+export function useIsVisible() {
+    const [isVisible, setIsVisible] = React.useState(false);
+    const observer = React.useRef(null);
+    const node = React.useCallback(n => {
+        if (observer.current) {
+            observer.current.disconnect();
+        }
+        if (n !== null) {
+            // this is called when the given element is mounted.
+            observer.current = new IntersectionObserver(([x]) => {
+                setIsVisible(x.isIntersecting);
+            }, { threshold: 0, root: null, rootMargin: '0px' });
+            observer.current.observe(n);
+        }
+        else {
+            // when unmounted
+        }
+    }, []);
+    return [node, isVisible];
+}
+/** Like `<details>` but can be programatically revealed using `setOpenRef`. */
+export function Details({ initiallyOpen, children: [summary, ...children], setOpenRef }) {
+    const [isOpen, setOpen] = React.useState(initiallyOpen === undefined ? false : initiallyOpen);
+    const setupEventListener = React.useCallback((node) => {
+        if (node !== undefined && node !== null) {
+            node.addEventListener('toggle', () => setOpen(node.open));
+        }
+    }, []);
+    if (setOpenRef)
+        setOpenRef(setOpen);
+    return (_jsxs("details", { ref: setupEventListener, open: isOpen, children: [summary, isOpen && children] }));
+}

package/dist/monaco-lean4/lean4-infoview/src/infoview/contexts.d.ts

@@ -0,0 +1,40 @@
+export declare const EditorContext: any;
+export declare const VersionContext: any;
+export declare const ConfigContext: any;
+export declare const LspDiagnosticsContext: any;
+export declare const ProgressContext: any;
+/**
+ * Certain infoview components and widget instances
+ * utilize data that has been introduced above a specific position
+ * in a Lean source file.
+ *
+ * For instance, if we declare a global constant with `def foo` on line 10,
+ * we can immediately display it in a widget on line 11.
+ * To achieve this, the widget code needs to have access
+ * to the environment on line 11 as that environment contains `foo`.
+ *
+ * {@link EnvPosContext} stores the position in the file
+ * from which an appropriate environment can be retrieved.
+ * This is used to look up global constants,
+ * in particular RPC methods (`@[server_rpc_method]`)
+ * and widget modules (`@[widget_module]`).
+ *
+ * Note that {@link EnvPosContext} may, but need not,
+ * be equal to any of the positions which the infoview keeps track of
+ * (such as the editor cursor position).
+ *
+ * #### Infoview implementation details
+ *
+ * In the infoview, {@link EnvPosContext} is set as follows:
+ * - in an `<InfoDisplay>`,
+ *   it is the position at which the info block is being displayed:
+ *   either a recent editor cursor position
+ *   (when shown in the at-cursor `<InfoDisplay>`,
+ *   this will lag behind the current editor cursor position
+ *   while the `<InfoDisplay>` is in the process of updating),
+ *   or a pinned position.
+ * - in an `<InteractiveMessage>` that comes from a diagnostic
+ *   emitted with a syntactic range,
+ *   it is the start of the diagnostic's `fullRange`.
+ */
+export declare const EnvPosContext: any;

package/dist/monaco-lean4/lean4-infoview/src/infoview/contexts.js

@@ -0,0 +1,44 @@
+import * as React from 'react';
+import { defaultInfoviewConfig } from '@leanprover/infoview-api';
+// Type-unsafe initializers for contexts which we immediately set up at the top-level.
+// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+export const EditorContext = React.createContext(null);
+export const VersionContext = React.createContext(undefined);
+export const ConfigContext = React.createContext(defaultInfoviewConfig);
+export const LspDiagnosticsContext = React.createContext(new Map());
+export const ProgressContext = React.createContext(new Map());
+/**
+ * Certain infoview components and widget instances
+ * utilize data that has been introduced above a specific position
+ * in a Lean source file.
+ *
+ * For instance, if we declare a global constant with `def foo` on line 10,
+ * we can immediately display it in a widget on line 11.
+ * To achieve this, the widget code needs to have access
+ * to the environment on line 11 as that environment contains `foo`.
+ *
+ * {@link EnvPosContext} stores the position in the file
+ * from which an appropriate environment can be retrieved.
+ * This is used to look up global constants,
+ * in particular RPC methods (`@[server_rpc_method]`)
+ * and widget modules (`@[widget_module]`).
+ *
+ * Note that {@link EnvPosContext} may, but need not,
+ * be equal to any of the positions which the infoview keeps track of
+ * (such as the editor cursor position).
+ *
+ * #### Infoview implementation details
+ *
+ * In the infoview, {@link EnvPosContext} is set as follows:
+ * - in an `<InfoDisplay>`,
+ *   it is the position at which the info block is being displayed:
+ *   either a recent editor cursor position
+ *   (when shown in the at-cursor `<InfoDisplay>`,
+ *   this will lag behind the current editor cursor position
+ *   while the `<InfoDisplay>` is in the process of updating),
+ *   or a pinned position.
+ * - in an `<InteractiveMessage>` that comes from a diagnostic
+ *   emitted with a syntactic range,
+ *   it is the start of the diagnostic's `fullRange`.
+ */
+export const EnvPosContext = React.createContext(undefined);

package/dist/monaco-lean4/lean4-infoview/src/infoview/editorConnection.d.ts

@@ -0,0 +1,22 @@
+import type { Location } from 'vscode-languageserver-protocol';
+import { EditorApi, InfoviewAction, InfoviewActionKind, InfoviewApi, PlainGoal, PlainTermGoal } from '@leanprover/infoview-api';
+import { EventEmitter, Eventify } from './event';
+import { DocumentPosition } from './util';
+export type EditorEvents = Omit<Eventify<InfoviewApi>, 'requestedAction' | 'goToDefinition'> & {
+    requestedAction: EventEmitter<InfoviewAction, InfoviewActionKind>;
+    goToDefinition: EventEmitter<string, string>;
+};
+/** Provides higher-level wrappers around functionality provided by the editor,
+ * e.g. to insert a comment. See also {@link EditorApi}. */
+export declare class EditorConnection {
+    readonly api: EditorApi;
+    readonly events: EditorEvents;
+    constructor(api: EditorApi, events: EditorEvents);
+    /** Highlights the given range in a document in the editor. */
+    revealLocation(loc: Location): Promise<void>;
+    revealPosition(pos: DocumentPosition): Promise<void>;
+    /** Copies the text to a comment at the cursor position. */
+    copyToComment(text: string): Promise<void>;
+    requestPlainGoal(pos: DocumentPosition): Promise<PlainGoal | undefined>;
+    requestPlainTermGoal(pos: DocumentPosition): Promise<PlainTermGoal | undefined>;
+}

package/dist/monaco-lean4/lean4-infoview/src/infoview/editorConnection.js

@@ -0,0 +1,41 @@
+import { DocumentPosition } from './util';
+/** Provides higher-level wrappers around functionality provided by the editor,
+ * e.g. to insert a comment. See also {@link EditorApi}. */
+export class EditorConnection {
+    api;
+    events;
+    constructor(api, events) {
+        this.api = api;
+        this.events = events;
+    }
+    /** Highlights the given range in a document in the editor. */
+    async revealLocation(loc) {
+        const show = {
+            uri: loc.uri,
+            selection: loc.range,
+        };
+        await this.api.showDocument(show);
+    }
+    async revealPosition(pos) {
+        const loc = {
+            uri: pos.uri,
+            range: {
+                start: pos,
+                end: pos,
+            },
+        };
+        await this.revealLocation(loc);
+    }
+    /** Copies the text to a comment at the cursor position. */
+    async copyToComment(text) {
+        await this.api.insertText(`/-\n${text}\n-/`, 'above');
+    }
+    requestPlainGoal(pos) {
+        const params = DocumentPosition.toTdpp(pos);
+        return this.api.sendClientRequest(pos.uri, '$/lean/plainGoal', params);
+    }
+    requestPlainTermGoal(pos) {
+        const params = DocumentPosition.toTdpp(pos);
+        return this.api.sendClientRequest(pos.uri, '$/lean/plainTermGoal', params);
+    }
+}

package/dist/monaco-lean4/lean4-infoview/src/infoview/errors.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+/** Error boundary as described in https://reactjs.org/docs/error-boundaries.html */
+export declare class ErrorBoundary extends React.Component<{
+    children?: React.ReactNode;
+}, {
+    error: string | undefined;
+}> {
+    constructor(props: {});
+    static getDerivedStateFromError(error: any): {
+        error: any;
+    };
+    componentDidCatch(error: any, errorInfo: any): void;
+    render(): any;
+}

package/dist/monaco-lean4/lean4-infoview/src/infoview/errors.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from 'react';
+/** Error boundary as described in https://reactjs.org/docs/error-boundaries.html */
+export class ErrorBoundary extends React.Component {
+    constructor(props) {
+        super(props);
+        this.state = { error: undefined };
+    }
+    static getDerivedStateFromError(error) {
+        // Update state so the next render will show the fallback UI.
+        return { error: error.toString() };
+    }
+    componentDidCatch(error, errorInfo) {
+        // You can also log the error to an error reporting service
+        return;
+    }
+    render() {
+        if (this.state.error) {
+            // You can render any custom fallback UI
+            return (_jsxs("div", { children: [_jsx("h1", { children: "Error:" }), this.state.error, _jsx("br", {}), _jsx("br", {}), _jsx("a", { className: "link pointer dim ", onClick: () => this.setState({ error: undefined }), children: "Click to reload." })] }));
+        }
+        return this.props.children;
+    }
+}

package/dist/monaco-lean4/lean4-infoview/src/infoview/event.d.ts

@@ -0,0 +1,33 @@
+import type { Disposable } from 'vscode-languageserver-protocol';
+export declare class EventEmitter<E, in out K> {
+    private freshId;
+    private handlers;
+    private handlersWithKey;
+    current?: E;
+    /**
+     * Register a handler that will receive events from this emitter
+     * and return a closure that removes the handler registration.
+     *
+     * If `key` is specified, only events fired with that key
+     * will be propagated to this handler.
+     */
+    on(handler: (_: E) => void, key?: K): Disposable;
+    /**
+     * Propagate the event to registered handlers.
+     *
+     * The event is propagated to all keyless handlers.
+     * Furthermore if `key` is provided,
+     * the event is also propagated to handlers registered with that key.
+     */
+    fire(event: E, key?: K): void;
+}
+type ExcludeNonEvent<T, U> = T extends (...args: any) => Promise<void> ? U : never;
+/**
+ * Turn all fields in `T` which extend `(...args: As) => Promise<void>`
+ * into event emitter fields `f: EventEmitter<As>`.
+ * Other fields are removed.
+ */
+export type Eventify<T> = {
+    [P in keyof T as ExcludeNonEvent<T[P], P>]: T[P] extends (arg: infer A) => Promise<void> ? EventEmitter<A, never> : T[P] extends (...args: infer As) => Promise<void> ? EventEmitter<As, never> : never;
+};
+export {};

package/dist/monaco-lean4/lean4-infoview/src/infoview/event.js

@@ -0,0 +1,57 @@
+export class EventEmitter {
+    freshId = 0;
+    handlers = new Map();
+    handlersWithKey = new Map();
+    current;
+    /**
+     * Register a handler that will receive events from this emitter
+     * and return a closure that removes the handler registration.
+     *
+     * If `key` is specified, only events fired with that key
+     * will be propagated to this handler.
+     */
+    on(handler, key) {
+        const id = this.freshId;
+        this.freshId += 1;
+        if (key) {
+            const handlersForKey = this.handlersWithKey.get(key) ?? [];
+            handlersForKey.push(handler);
+            this.handlersWithKey.set(key, handlersForKey);
+        }
+        else {
+            this.handlers.set(id, handler);
+        }
+        return {
+            dispose: () => {
+                if (key) {
+                    const handlersForKey = this.handlersWithKey.get(key) ?? [];
+                    // We assume that no key has so many handlers registered
+                    // that the linear `filter` operation becomes a perf issue.
+                    this.handlersWithKey.set(key, handlersForKey.filter(h => h !== handler));
+                }
+                else {
+                    this.handlers.delete(id);
+                }
+            },
+        };
+    }
+    /**
+     * Propagate the event to registered handlers.
+     *
+     * The event is propagated to all keyless handlers.
+     * Furthermore if `key` is provided,
+     * the event is also propagated to handlers registered with that key.
+     */
+    fire(event, key) {
+        this.current = event;
+        for (const h of this.handlers.values()) {
+            h(event);
+        }
+        if (key) {
+            const handlersForKey = this.handlersWithKey.get(key) ?? [];
+            for (const h of handlersForKey) {
+                h(event);
+            }
+        }
+    }
+}

package/dist/monaco-lean4/lean4-infoview/src/infoview/goalLocation.d.ts

@@ -0,0 +1,61 @@
+import { FVarId, MVarId, SubexprPos } from '@leanprover/infoview-api';
+import * as React from 'react';
+import { HoverState } from './tooltips';
+/**
+ * A location within a goal. It is either:
+ * - one of the hypotheses; or
+ * - (a subexpression of) the type of one of the hypotheses; or
+ * - (a subexpression of) the value of one of the let-bound hypotheses; or
+ * - (a subexpression of) the goal type. */
+export type GoalLocation = {
+    hyp: FVarId;
+} | {
+    hypType: [FVarId, SubexprPos];
+} | {
+    hypValue: [FVarId, SubexprPos];
+} | {
+    target: SubexprPos;
+};
+export declare namespace GoalLocation {
+    function isEqual(l1: GoalLocation, l2: GoalLocation): boolean;
+    function withSubexprPos(l: GoalLocation, p: SubexprPos): GoalLocation;
+}
+/**
+ * A location within a goal state. It identifies a specific goal together with a {@link GoalLocation}
+ * within it.  */
+export interface GoalsLocation {
+    /** Which goal the location is in. */
+    mvarId: MVarId;
+    loc: GoalLocation;
+}
+export declare namespace GoalsLocation {
+    function isEqual(l1: GoalsLocation, l2: GoalsLocation): boolean;
+    function withSubexprPos(l: GoalsLocation, p: SubexprPos): GoalsLocation;
+}
+/**
+ * An interface available through a React context in components where selecting subexpressions
+ * makes sense. Currently this is only the goal state display. There, {@link GoalLocation}s can be
+ * selected. */
+export interface Locations {
+    isSelected: (l: GoalsLocation) => boolean;
+    setSelected: (l: GoalsLocation, fn: React.SetStateAction<boolean>) => void;
+    /**
+     * A template for the location of the current component. It is defined if and only if the current
+     * component is a subexpression of a selectable expression. We use
+     * {@link GoalsLocation.withSubexprPos} to map this template to a complete location. */
+    subexprTemplate?: GoalsLocation;
+}
+export declare const LocationsContext: any;
+type SelectableLocationProps = React.PropsWithoutRef<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>> & {
+    locs?: Locations;
+    loc?: GoalsLocation;
+    alwaysHighlight: boolean;
+    setHoverState?: React.Dispatch<React.SetStateAction<HoverState>>;
+};
+/**
+ * A `<span>` with a corresponding {@link GoalsLocation} which can be (un)selected using shift-click.
+ * If `locs` or `loc` is `undefined`, selection functionality is turned off. The element is also
+ * highlighted when hovered over if `alwaysHighlight` is `true` or `locs` and `loc` are both defined.
+ * `setHoverState` is passed through to {@link DetectHoverSpan}. */
+export declare function SelectableLocation(props_: SelectableLocationProps): JSX.Element;
+export {};

package/dist/monaco-lean4/lean4-infoview/src/infoview/goalLocation.js

@@ -0,0 +1,87 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from 'react';
+import { DetectHoverSpan } from './tooltips';
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export var GoalLocation;
+(function (GoalLocation) {
+    function isEqual(l1, l2) {
+        if ('hyp' in l1)
+            return 'hyp' in l2 ? l1.hyp === l2.hyp : false;
+        else if ('hypType' in l1)
+            return 'hypType' in l2 ? l1.hypType[0] === l2.hypType[0] && l1.hypType[1] === l2.hypType[1] : false;
+        else if ('hypValue' in l1)
+            return 'hypValue' in l2 ? l1.hypValue[0] === l2.hypValue[0] && l1.hypValue[1] === l2.hypValue[1] : false;
+        else if ('target' in l1)
+            return 'target' in l2 ? l1.target === l2.target : false;
+        else
+            return false;
+    }
+    GoalLocation.isEqual = isEqual;
+    function withSubexprPos(l, p) {
+        if ('hyp' in l)
+            return l;
+        else if ('hypType' in l)
+            return { hypType: [l.hypType[0], p] };
+        else if ('hypValue' in l)
+            return { hypValue: [l.hypValue[0], p] };
+        else if ('target' in l)
+            return { target: p };
+        else
+            throw new Error(`unrecognized GoalLocation variant ${JSON.stringify(l)}`);
+    }
+    GoalLocation.withSubexprPos = withSubexprPos;
+})(GoalLocation || (GoalLocation = {}));
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export var GoalsLocation;
+(function (GoalsLocation) {
+    function isEqual(l1, l2) {
+        return l1.mvarId === l2.mvarId && GoalLocation.isEqual(l1.loc, l2.loc);
+    }
+    GoalsLocation.isEqual = isEqual;
+    function withSubexprPos(l, p) {
+        return { ...l, loc: GoalLocation.withSubexprPos(l.loc, p) };
+    }
+    GoalsLocation.withSubexprPos = withSubexprPos;
+})(GoalsLocation || (GoalsLocation = {}));
+export const LocationsContext = React.createContext(undefined);
+/**
+ * A `<span>` with a corresponding {@link GoalsLocation} which can be (un)selected using shift-click.
+ * If `locs` or `loc` is `undefined`, selection functionality is turned off. The element is also
+ * highlighted when hovered over if `alwaysHighlight` is `true` or `locs` and `loc` are both defined.
+ * `setHoverState` is passed through to {@link DetectHoverSpan}. */
+export function SelectableLocation(props_) {
+    const { locs, loc, alwaysHighlight, setHoverState: setParentHoverState, ...props } = props_;
+    const shouldHighlight = alwaysHighlight || (!!locs && !!loc);
+    const [hoverState, setHoverState] = React.useState('off');
+    let spanClassName = '';
+    if (shouldHighlight) {
+        spanClassName += 'highlightable ';
+        if (hoverState !== 'off')
+            spanClassName += 'highlight ';
+        if (props.className)
+            spanClassName += props.className;
+    }
+    const innerSpanClassName = 'highlightable ' + (locs && loc && locs.isSelected(loc) ? 'highlight-selected ' : '');
+    const setHoverStateAll = React.useCallback(val => {
+        setHoverState(val);
+        if (setParentHoverState)
+            setParentHoverState(val);
+    }, [setParentHoverState]);
+    return (_jsx(DetectHoverSpan, { ...props, setHoverState: setHoverStateAll, className: spanClassName, onClick: e => {
+            // On shift-click, if we are in a context where selecting subexpressions makes sense,
+            // (un)select the current subexpression.
+            if (e.shiftKey && locs && loc) {
+                locs.setSelected(loc, on => !on);
+                e.stopPropagation();
+            }
+            if (props.onClick)
+                props.onClick(e);
+        }, onPointerDown: e => {
+            // Since shift-click on this component is a custom selection, when shift is held prevent
+            // the default action which on text is to start a text selection.
+            if (e.shiftKey)
+                e.preventDefault();
+            if (props.onPointerDown)
+                props.onPointerDown(e);
+        }, children: _jsx("span", { className: innerSpanClassName, children: props.children }) }));
+}

package/dist/monaco-lean4/lean4-infoview/src/infoview/goals.d.ts

@@ -0,0 +1,11 @@
+import { InteractiveGoals } from '@leanprover/infoview-api';
+export declare function goalsToString(goals: InteractiveGoals): string;
+/**
+ * Displays the hypotheses, target type and optional case label of a goal according to the
+ * provided `filter`. */
+export declare const Goal: any;
+/**
+ * Display goals together with a header containing the provided children as well as buttons
+ * to control how the goals are displayed.
+ */
+export declare const FilteredGoals: any;