nucleus-core-ts 0.9.781 → 0.9.783

package/dist/fe/components/IntegrationsPage/components/ParamBindingRow.js

@@ -0,0 +1,180 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useId } from 'react';
+import { integrationsPageTheme as theme } from '../theme';
+import { Field } from './Primitives';
+export function ParamBindingRow({ binding, onChange, onRemove, siblings, entities, disabled }) {
+    const rowId = useId();
+    const changeSource = (from)=>{
+        if (from === 'static') onChange({
+            param: binding.param,
+            from: 'static',
+            value: ''
+        });
+        else if (from === 'endpoint') onChange({
+            param: binding.param,
+            from: 'endpoint',
+            endpointId: siblings[0]?.id ?? '',
+            field: ''
+        });
+        else onChange({
+            param: binding.param,
+            from: 'entity',
+            entity: entities[0]?.entity ?? '',
+            field: ''
+        });
+    };
+    return /*#__PURE__*/ _jsxs("div", {
+        className: "flex flex-col gap-2 rounded-lg border border-slate-200 p-3 sm:flex-row sm:items-end dark:border-slate-800",
+        children: [
+            /*#__PURE__*/ _jsx(Field, {
+                htmlFor: `${rowId}-from`,
+                label: binding.param,
+                children: /*#__PURE__*/ _jsxs("select", {
+                    className: theme.field.input,
+                    disabled: disabled,
+                    id: `${rowId}-from`,
+                    onChange: (event)=>changeSource(event.target.value),
+                    value: binding.from,
+                    children: [
+                        /*#__PURE__*/ _jsx("option", {
+                            value: "static",
+                            children: "A fixed value"
+                        }),
+                        /*#__PURE__*/ _jsx("option", {
+                            value: "endpoint",
+                            children: "A field of another endpoint"
+                        }),
+                        /*#__PURE__*/ _jsx("option", {
+                            value: "entity",
+                            children: "A column of one of our tables"
+                        })
+                    ]
+                })
+            }),
+            /*#__PURE__*/ _jsx(ParamBindingValueFields, {
+                binding: binding,
+                disabled: disabled,
+                entities: entities,
+                onChange: onChange,
+                rowId: rowId,
+                siblings: siblings
+            }),
+            /*#__PURE__*/ _jsx("button", {
+                "aria-label": `Remove the binding for ${binding.param}`,
+                className: theme.button.ghost,
+                disabled: disabled,
+                onClick: onRemove,
+                type: "button",
+                children: "Remove"
+            })
+        ]
+    });
+}
+/** The half of a row that depends on which source was chosen. */ function ParamBindingValueFields({ binding, onChange, siblings, entities, disabled, rowId }) {
+    if (binding.from === 'static') {
+        return /*#__PURE__*/ _jsx(Field, {
+            htmlFor: `${rowId}-value`,
+            label: "Value",
+            children: /*#__PURE__*/ _jsx("input", {
+                className: theme.field.input,
+                disabled: disabled,
+                id: `${rowId}-value`,
+                onChange: (event)=>onChange({
+                        ...binding,
+                        value: event.target.value
+                    }),
+                placeholder: "e.g. ACTIVE",
+                value: binding.value
+            })
+        });
+    }
+    if (binding.from === 'endpoint') {
+        return /*#__PURE__*/ _jsxs(_Fragment, {
+            children: [
+                /*#__PURE__*/ _jsx(Field, {
+                    hint: "Fetched first; this endpoint is then called once per record it returns.",
+                    htmlFor: `${rowId}-endpoint`,
+                    label: "From endpoint",
+                    children: /*#__PURE__*/ _jsx("select", {
+                        className: theme.field.input,
+                        disabled: disabled,
+                        id: `${rowId}-endpoint`,
+                        onChange: (event)=>onChange({
+                                ...binding,
+                                endpointId: event.target.value
+                            }),
+                        value: binding.endpointId,
+                        children: siblings.map((sibling)=>/*#__PURE__*/ _jsx("option", {
+                                value: sibling.id,
+                                children: sibling.tag
+                            }, sibling.id))
+                    })
+                }),
+                /*#__PURE__*/ _jsx(Field, {
+                    htmlFor: `${rowId}-field`,
+                    label: "Field",
+                    children: /*#__PURE__*/ _jsx("input", {
+                        className: theme.field.input,
+                        disabled: disabled,
+                        id: `${rowId}-field`,
+                        onChange: (event)=>onChange({
+                                ...binding,
+                                field: event.target.value
+                            }),
+                        placeholder: "e.g. name",
+                        value: binding.field
+                    })
+                })
+            ]
+        });
+    }
+    const selected = entities.find((entity)=>entity.entity === binding.entity);
+    return /*#__PURE__*/ _jsxs(_Fragment, {
+        children: [
+            /*#__PURE__*/ _jsx(Field, {
+                htmlFor: `${rowId}-entity`,
+                label: "From table",
+                children: /*#__PURE__*/ _jsx("select", {
+                    className: theme.field.input,
+                    disabled: disabled,
+                    id: `${rowId}-entity`,
+                    onChange: (event)=>onChange({
+                            ...binding,
+                            entity: event.target.value,
+                            field: ''
+                        }),
+                    value: binding.entity,
+                    children: entities.map((entity)=>/*#__PURE__*/ _jsx("option", {
+                            value: entity.entity,
+                            children: entity.label
+                        }, entity.entity))
+                })
+            }),
+            /*#__PURE__*/ _jsx(Field, {
+                htmlFor: `${rowId}-column`,
+                label: "Column",
+                children: /*#__PURE__*/ _jsxs("select", {
+                    className: theme.field.input,
+                    disabled: disabled,
+                    id: `${rowId}-column`,
+                    onChange: (event)=>onChange({
+                            ...binding,
+                            field: event.target.value
+                        }),
+                    value: binding.field,
+                    children: [
+                        /*#__PURE__*/ _jsx("option", {
+                            value: "",
+                            children: "Choose a column…"
+                        }),
+                        (selected?.fields ?? []).map((field)=>/*#__PURE__*/ _jsx("option", {
+                                value: field,
+                                children: field
+                            }, field))
+                    ]
+                })
+            })
+        ]
+    });
+}

package/dist/fe/components/IntegrationsPage/components/ParamBindingRows.d.ts

@@ -0,0 +1,33 @@
+import type { IntegrationEndpoint, ParamBindingValue } from '../types';
+export type ParamBindingRowsProps = {
+    /** Parameter names the path and query need filling. */
+    required: string[];
+    value: ParamBindingValue[];
+    onChange: (next: ParamBindingValue[]) => void;
+    /** Other endpoints of this connection, as possible parents. */
+    siblings: IntegrationEndpoint[];
+    /** Target entities, for binding a parameter to one of our own columns. */
+    entities: {
+        entity: string;
+        label: string;
+        fields: string[];
+    }[];
+    disabled?: boolean;
+};
+/**
+ * Where each parameter of an endpoint gets its value.
+ *
+ * This is what makes an endpoint that is only reachable per item — `/thing/{id}`,
+ * with no endpoint that lists everything — importable at all. Without it such an
+ * endpoint could be TESTED from the panel (the sample screen asks for a value by
+ * hand) but never imported, because a run had nothing to supply the parameter
+ * from. That gap is exactly why this screen exists.
+ *
+ * Three sources, and the difference matters:
+ *  - a fixed value, the same on every call;
+ *  - a field of another endpoint's records — one call per record, which is the
+ *    fan-out;
+ *  - a column of one of our own tables, for "fetch the detail of everything I
+ *    already have".
+ */
+export declare function ParamBindingRows({ required, value, onChange, siblings, entities, disabled, }: ParamBindingRowsProps): import("react/jsx-runtime").JSX.Element;

package/dist/fe/components/IntegrationsPage/components/ParamBindingRows.js

@@ -0,0 +1,100 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useId } from 'react';
+import { integrationsPageTheme as theme } from '../theme';
+import { ParamBindingRow } from './ParamBindingRow';
+import { Notice } from './Primitives';
+/**
+ * Where each parameter of an endpoint gets its value.
+ *
+ * This is what makes an endpoint that is only reachable per item — `/thing/{id}`,
+ * with no endpoint that lists everything — importable at all. Without it such an
+ * endpoint could be TESTED from the panel (the sample screen asks for a value by
+ * hand) but never imported, because a run had nothing to supply the parameter
+ * from. That gap is exactly why this screen exists.
+ *
+ * Three sources, and the difference matters:
+ *  - a fixed value, the same on every call;
+ *  - a field of another endpoint's records — one call per record, which is the
+ *    fan-out;
+ *  - a column of one of our own tables, for "fetch the detail of everything I
+ *    already have".
+ */ export function ParamBindingRows({ required, value, onChange, siblings, entities, disabled = false }) {
+    const groupId = useId();
+    const bound = new Set(value.map((binding)=>binding.param));
+    const unbound = required.filter((name)=>!bound.has(name));
+    const update = (index, next)=>{
+        onChange(value.map((binding, position)=>position === index ? next : binding));
+    };
+    const remove = (index)=>{
+        onChange(value.filter((_binding, position)=>position !== index));
+    };
+    const add = (param)=>{
+        onChange([
+            ...value,
+            {
+                param,
+                from: 'static',
+                value: ''
+            }
+        ]);
+    };
+    return /*#__PURE__*/ _jsxs("section", {
+        "aria-labelledby": `${groupId}-title`,
+        className: theme.card.wrapper,
+        children: [
+            /*#__PURE__*/ _jsx("header", {
+                className: theme.card.header,
+                children: /*#__PURE__*/ _jsx("h4", {
+                    className: theme.card.title,
+                    id: `${groupId}-title`,
+                    children: "Parameter values"
+                })
+            }),
+            /*#__PURE__*/ _jsxs("div", {
+                className: theme.card.body,
+                children: [
+                    required.length === 0 ? /*#__PURE__*/ _jsxs("p", {
+                        className: theme.field.hint,
+                        children: [
+                            "This endpoint takes no parameters. Add a ",
+                            /*#__PURE__*/ _jsx("code", {
+                                children: '{name}'
+                            }),
+                            " token to its path if it needs one."
+                        ]
+                    }) : null,
+                    unbound.length > 0 ? /*#__PURE__*/ _jsxs(Notice, {
+                        title: "These parameters have no value yet",
+                        tone: "warning",
+                        children: [
+                            unbound.join(', '),
+                            " — an import cannot run until every one of them is bound. Add a binding for each below."
+                        ]
+                    }) : null,
+                    value.map((binding, index)=>/*#__PURE__*/ _jsx(ParamBindingRow, {
+                            binding: binding,
+                            disabled: disabled,
+                            entities: entities,
+                            onChange: (next)=>update(index, next),
+                            onRemove: ()=>remove(index),
+                            siblings: siblings
+                        }, `${binding.param}-${index}`)),
+                    unbound.length > 0 ? /*#__PURE__*/ _jsx("div", {
+                        className: "flex flex-wrap gap-2",
+                        children: unbound.map((name)=>/*#__PURE__*/ _jsxs("button", {
+                                className: theme.button.secondary,
+                                disabled: disabled,
+                                onClick: ()=>add(name),
+                                type: "button",
+                                children: [
+                                    "Bind ",
+                                    name
+                                ]
+                            }, name))
+                    }) : null
+                ]
+            })
+        ]
+    });
+}

package/dist/fe/components/IntegrationsPage/components/Primitives.d.ts

@@ -0,0 +1,65 @@
+import type { ReactNode } from 'react';
+/**
+ * The five pieces every other screen in this panel is built from.
+ *
+ * Nothing here holds state or fetches anything: each one takes what it shows and
+ * paints it with a class the theme already owns, so a colour is changed in one
+ * file and no component can drift into a light-only or a dark-only look.
+ */
+export type BadgeTone = 'neutral' | 'success' | 'warning' | 'danger' | 'info';
+export type NoticeTone = 'info' | 'warning' | 'danger';
+export type BadgeProps = {
+    tone: BadgeTone;
+    children: ReactNode;
+};
+/** A status word — a run's outcome, an auth type, an enabled flag. */
+export declare function Badge({ tone, children }: BadgeProps): import("react/jsx-runtime").JSX.Element;
+export type StatProps = {
+    label: string;
+    value: ReactNode;
+    tone?: BadgeTone;
+};
+/**
+ * One number with its name under it.
+ *
+ * The tone tints the whole cell rather than the digits alone: an operator scans
+ * a row of counts, and a red *cell* is findable where red text is not.
+ */
+export declare function Stat({ label, value, tone }: StatProps): import("react/jsx-runtime").JSX.Element;
+export type NoticeProps = {
+    tone: NoticeTone;
+    title: string;
+    children?: ReactNode;
+};
+/**
+ * Something the operator has to read before acting.
+ *
+ * A danger notice is announced immediately because it is the one that reports a
+ * write that failed or is about to delete rows; the calmer tones wait their turn.
+ */
+export declare function Notice({ tone, title, children }: NoticeProps): import("react/jsx-runtime").JSX.Element;
+export type FieldProps = {
+    label: string;
+    htmlFor: string;
+    hint?: string;
+    error?: string | null;
+    children: ReactNode;
+};
+/**
+ * A labelled control.
+ *
+ * The hint and the error carry ids derived from the control's own id so the
+ * caller can point `aria-describedby` at them; the label is not optional,
+ * because a form of unlabelled boxes is unusable with a screen reader.
+ */
+export declare function Field({ label, htmlFor, hint, error, children }: FieldProps): import("react/jsx-runtime").JSX.Element;
+export type CodeBlockProps = {
+    children: ReactNode;
+};
+/**
+ * One line of verbatim text — a URL, a JSON path, a header name.
+ *
+ * It scrolls sideways instead of wrapping: a wrapped path invites the reader to
+ * copy a line break into a field where it will silently break the request.
+ */
+export declare function CodeBlock({ children }: CodeBlockProps): import("react/jsx-runtime").JSX.Element;

package/dist/fe/components/IntegrationsPage/components/Primitives.js

@@ -0,0 +1,94 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cn } from '../../../utils/cn';
+import { integrationsPageTheme } from '../theme';
+const theme = integrationsPageTheme;
+/** A status word — a run's outcome, an auth type, an enabled flag. */ export function Badge({ tone, children }) {
+    return /*#__PURE__*/ _jsx("span", {
+        className: cn(theme.badge.base, theme.badge[tone]),
+        children: children
+    });
+}
+/**
+ * One number with its name under it.
+ *
+ * The tone tints the whole cell rather than the digits alone: an operator scans
+ * a row of counts, and a red *cell* is findable where red text is not.
+ */ export function Stat({ label, value, tone }) {
+    return /*#__PURE__*/ _jsxs("div", {
+        className: cn(theme.stat.cell, tone ? theme.badge[tone] : undefined),
+        children: [
+            /*#__PURE__*/ _jsx("span", {
+                className: theme.stat.value,
+                children: value
+            }),
+            /*#__PURE__*/ _jsx("span", {
+                className: theme.stat.label,
+                children: label
+            })
+        ]
+    });
+}
+/**
+ * Something the operator has to read before acting.
+ *
+ * A danger notice is announced immediately because it is the one that reports a
+ * write that failed or is about to delete rows; the calmer tones wait their turn.
+ */ export function Notice({ tone, title, children }) {
+    return /*#__PURE__*/ _jsxs("section", {
+        className: theme.notice[tone],
+        role: tone === 'danger' ? 'alert' : 'status',
+        children: [
+            /*#__PURE__*/ _jsx("p", {
+                className: theme.notice.title,
+                children: title
+            }),
+            children ? /*#__PURE__*/ _jsx("div", {
+                className: theme.notice.body,
+                children: children
+            }) : null
+        ]
+    });
+}
+/**
+ * A labelled control.
+ *
+ * The hint and the error carry ids derived from the control's own id so the
+ * caller can point `aria-describedby` at them; the label is not optional,
+ * because a form of unlabelled boxes is unusable with a screen reader.
+ */ export function Field({ label, htmlFor, hint, error, children }) {
+    return /*#__PURE__*/ _jsxs("div", {
+        className: theme.field.wrapper,
+        children: [
+            /*#__PURE__*/ _jsx("label", {
+                className: theme.field.label,
+                htmlFor: htmlFor,
+                children: label
+            }),
+            children,
+            hint ? /*#__PURE__*/ _jsx("span", {
+                className: theme.field.hint,
+                id: `${htmlFor}-hint`,
+                children: hint
+            }) : null,
+            error ? /*#__PURE__*/ _jsx("span", {
+                className: theme.field.error,
+                id: `${htmlFor}-error`,
+                children: error
+            }) : null
+        ]
+    });
+}
+/**
+ * One line of verbatim text — a URL, a JSON path, a header name.
+ *
+ * It scrolls sideways instead of wrapping: a wrapped path invites the reader to
+ * copy a line break into a field where it will silently break the request.
+ */ export function CodeBlock({ children }) {
+    return /*#__PURE__*/ _jsx("pre", {
+        className: cn(theme.code, 'whitespace-pre'),
+        children: /*#__PURE__*/ _jsx("code", {
+            children: children
+        })
+    });
+}

package/dist/fe/components/IntegrationsPage/components/RunConfirmStep.d.ts

@@ -0,0 +1,10 @@
+export type RunConfirmStepProps = {
+    /** One line per destructive effect, already counted where a plan allowed it. */
+    lines: string[];
+    /** False when the operator skipped the preview, so the lines carry no counts. */
+    counted: boolean;
+    working: boolean;
+    onConfirm: () => void;
+    onDismiss: () => void;
+};
+export declare function RunConfirmStep({ lines, counted, working, onConfirm, onDismiss, }: RunConfirmStepProps): import("react/jsx-runtime").JSX.Element;

package/dist/fe/components/IntegrationsPage/components/RunConfirmStep.js

@@ -0,0 +1,48 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { integrationsPageTheme } from '../theme';
+import { Notice } from './Primitives';
+/**
+ * The step between "Run import" and a destroyed table.
+ *
+ * It appears only when the server says the run needs confirming, and it says what
+ * goes away with a NUMBER in front of it. A confirmation that reads "are you
+ * sure?" transfers no information, so this one refuses to be that.
+ */ const theme = integrationsPageTheme;
+export function RunConfirmStep({ lines, counted, working, onConfirm, onDismiss }) {
+    return /*#__PURE__*/ _jsxs(Notice, {
+        tone: "danger",
+        title: "This import destroys data. Read what it removes, then confirm.",
+        children: [
+            /*#__PURE__*/ _jsx("ul", {
+                className: "flex list-disc flex-col gap-1 pl-5",
+                children: lines.map((line)=>/*#__PURE__*/ _jsx("li", {
+                        children: line
+                    }, line))
+            }),
+            counted ? null : /*#__PURE__*/ _jsx("p", {
+                className: "mt-2",
+                children: "These counts are unknown because nothing was previewed. Run a preview first if you want to know how many rows this removes before it removes them."
+            }),
+            /*#__PURE__*/ _jsxs("div", {
+                className: "mt-3 flex flex-wrap items-center gap-2",
+                children: [
+                    /*#__PURE__*/ _jsx("button", {
+                        className: theme.button.danger,
+                        disabled: working,
+                        onClick: onConfirm,
+                        type: "button",
+                        children: working ? 'Starting…' : 'Run it and remove those rows'
+                    }),
+                    /*#__PURE__*/ _jsx("button", {
+                        className: theme.button.secondary,
+                        disabled: working,
+                        onClick: onDismiss,
+                        type: "button",
+                        children: "Keep them, do not run"
+                    })
+                ]
+            })
+        ]
+    });
+}

package/dist/fe/components/IntegrationsPage/components/RunHistory.d.ts

@@ -0,0 +1,10 @@
+import type { IntegrationsActions } from '../types';
+export type RunHistoryProps = {
+    actions: IntegrationsActions;
+    /** Scopes the history to one mapping. Null lists the runs of every mapping. */
+    mappingId: string | null;
+    /** Bumped by the caller after a run finishes or is undone; refetches page 1. */
+    refreshKey: number;
+    onRefresh: () => void;
+};
+export declare function RunHistory({ actions, mappingId, refreshKey, onRefresh }: RunHistoryProps): import("react/jsx-runtime").JSX.Element;

package/dist/fe/components/IntegrationsPage/components/RunHistory.js

@@ -0,0 +1,124 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useEffectEvent } from 'react';
+import { useIntegrationsStore } from '../store';
+import { integrationsPageTheme } from '../theme';
+import { Notice } from './Primitives';
+import { RunHistoryRow } from './RunHistoryRow';
+import { ListSkeleton } from './Skeletons';
+import { useInfiniteList } from './useInfiniteList';
+/**
+ * Every run, newest first, one page at a time.
+ *
+ * The server pages, sorts and scopes it — nothing is filtered here, so a table
+ * with a hundred thousand runs behaves exactly like a table with ten. The
+ * sentinel at the bottom is what asks for the next page.
+ */ const theme = integrationsPageTheme;
+const PAGE_SIZE = 20;
+export function RunHistory({ actions, mappingId, refreshKey, onRefresh }) {
+    const store = useIntegrationsStore();
+    const list = useInfiniteList({
+        load: (page)=>actions.listRuns({
+                page,
+                limit: PAGE_SIZE,
+                sort: [
+                    {
+                        field: 'createdAt',
+                        direction: 'desc'
+                    }
+                ],
+                ...mappingId ? {
+                    mappingId
+                } : {}
+            }).then((result)=>({
+                    items: result.items,
+                    total: result.meta?.totalItems ?? result.items.length
+                })),
+        deps: [
+            mappingId,
+            refreshKey
+        ],
+        pageSize: PAGE_SIZE
+    });
+    // Mirrored into the store so the tab strip can show how many runs there are.
+    // Without this the counter read 0 forever, which on the one tab that exists to
+    // show history is worse than showing nothing.
+    const publishRuns = useEffectEvent(()=>{
+        store.setRuns(list.items, list.total);
+    });
+    const publishLoading = useEffectEvent(()=>{
+        store.setRunsLoading(list.loading);
+    });
+    useEffect(()=>{
+        publishRuns();
+    }, [
+        list.items,
+        list.total
+    ]);
+    useEffect(()=>{
+        publishLoading();
+    }, [
+        list.loading
+    ]);
+    const firstPagePending = list.loading && list.items.length === 0;
+    return /*#__PURE__*/ _jsxs("section", {
+        className: theme.card.wrapper,
+        children: [
+            /*#__PURE__*/ _jsxs("header", {
+                className: theme.card.header,
+                children: [
+                    /*#__PURE__*/ _jsx("h3", {
+                        className: theme.card.title,
+                        children: "History"
+                    }),
+                    /*#__PURE__*/ _jsx("span", {
+                        className: theme.field.hint,
+                        children: mappingId ? `${list.total} run(s) for this mapping` : `${list.total} run(s)`
+                    })
+                ]
+            }),
+            /*#__PURE__*/ _jsxs("div", {
+                className: theme.card.body,
+                children: [
+                    firstPagePending ? /*#__PURE__*/ _jsx(ListSkeleton, {
+                        rows: 4
+                    }) : null,
+                    list.error ? /*#__PURE__*/ _jsxs(Notice, {
+                        title: "This list could not be loaded",
+                        tone: "danger",
+                        children: [
+                            list.error,
+                            ' ',
+                            /*#__PURE__*/ _jsx("button", {
+                                className: theme.button.ghost,
+                                onClick: list.reload,
+                                type: "button",
+                                children: "Try again"
+                            })
+                        ]
+                    }) : null,
+                    !firstPagePending && list.items.length === 0 && !list.error ? /*#__PURE__*/ _jsx("p", {
+                        className: theme.list.empty,
+                        children: "Nothing has run yet. A preview writes nothing; the first entry appears here once an import is started."
+                    }) : null,
+                    list.items.length > 0 ? /*#__PURE__*/ _jsx("ul", {
+                        className: theme.list.wrapper,
+                        children: list.items.map((run)=>/*#__PURE__*/ _jsx(RunHistoryRow, {
+                                actions: actions,
+                                onReverted: onRefresh,
+                                run: run
+                            }, run.id))
+                    }) : null,
+                    list.loading && list.items.length > 0 ? /*#__PURE__*/ _jsx(ListSkeleton, {
+                        rows: 2
+                    }) : null,
+                    /*#__PURE__*/ _jsx("div", {
+                        "aria-hidden": "true",
+                        className: theme.list.sentinel,
+                        ref: list.sentinelRef
+                    })
+                ]
+            })
+        ]
+    });
+}

package/dist/fe/components/IntegrationsPage/components/RunHistoryRow.d.ts

@@ -0,0 +1,7 @@
+import type { IntegrationRun, IntegrationsActions } from '../types';
+export type RunHistoryRowProps = {
+    run: IntegrationRun;
+    actions: IntegrationsActions;
+    onReverted: () => void;
+};
+export declare function RunHistoryRow({ run, actions, onReverted }: RunHistoryRowProps): import("react/jsx-runtime").JSX.Element;