@delmaredigital/payload-experiments 0.0.0-stage → 0.1.0-rc.6

package/dist/admin/actions/AllocateDialog.js

@@ -0,0 +1,81 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useRef, useState } from 'react';
+import { Button } from '@payloadcms/ui';
+import { DialogFrame } from './ConfirmDialog.js';
+import { useApi } from '../useApi.js';
+import { reloadPage } from '../reload.js';
+import { REVIEW_COPY as C, REVIEW_HINTS } from '../copy/review.js';
+import { ACTIONS_COPY } from '../copy/actions.js';
+export function AllocateDialog({ id, allocation: current, onClose }) {
+    const api = useApi();
+    const [value, setValue] = useState(String(Math.min(100, current + 1)));
+    const [busy, setBusy] = useState(false);
+    const [error, setError] = useState(null);
+    const inFlight = useRef(false);
+    const allocation = Number(value);
+    const valid = value.trim() !== '' && Number.isInteger(allocation) && allocation > current && allocation <= 100;
+    async function submit() {
+        if (inFlight.current || !valid) return;
+        inFlight.current = true;
+        setBusy(true);
+        setError(null);
+        const body = {
+            allocation
+        };
+        const result = await api.allocate(id, body);
+        if (result.ok) {
+            reloadPage();
+            return;
+        }
+        setError(result.code === 'allocation-lower' ? REVIEW_HINTS['allocation-lower'] : result.message);
+        inFlight.current = false;
+        setBusy(false);
+    }
+    return /*#__PURE__*/ _jsxs(DialogFrame, {
+        title: C.raise,
+        onClose: ()=>{
+            if (!inFlight.current) onClose();
+        },
+        children: [
+            /*#__PURE__*/ _jsx("p", {
+                children: C.allocationBody
+            }),
+            /*#__PURE__*/ _jsxs("label", {
+                children: [
+                    C.allocation,
+                    /*#__PURE__*/ _jsx("input", {
+                        type: "number",
+                        min: current + 1,
+                        max: 100,
+                        step: 1,
+                        value: value,
+                        disabled: busy,
+                        onChange: (event)=>setValue(event.target.value)
+                    })
+                ]
+            }),
+            !valid ? /*#__PURE__*/ _jsx("p", {
+                children: C.allocationInvalid
+            }) : null,
+            error ? /*#__PURE__*/ _jsx("p", {
+                role: "alert",
+                children: error
+            }) : null,
+            /*#__PURE__*/ _jsx(Button, {
+                disabled: busy || !valid,
+                onClick: ()=>{
+                    void submit();
+                },
+                children: C.raise
+            }),
+            /*#__PURE__*/ _jsx(Button, {
+                disabled: busy,
+                onClick: ()=>{
+                    if (!inFlight.current) onClose();
+                },
+                children: ACTIONS_COPY.cancel
+            })
+        ]
+    });
+}

package/dist/admin/actions/ConfirmDialog.d.ts

@@ -0,0 +1,14 @@
+import type { ReactNode } from 'react';
+import type { DocId } from '../../types/contracts.js';
+import type { ExperimentAction } from './actions.model.js';
+export declare function DialogFrame({ title, onClose, children }: {
+    title: string;
+    onClose: () => void;
+    children: ReactNode;
+}): import("react").ReactPortal;
+export declare function ConfirmDialog({ id, action, winnerLabel, onClose }: {
+    id: DocId;
+    action: ExperimentAction;
+    winnerLabel: string;
+    onClose: () => void;
+}): import("react").JSX.Element;

package/dist/admin/actions/ConfirmDialog.js

@@ -0,0 +1,192 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useId, useRef, useState } from 'react';
+import { createPortal } from 'react-dom';
+import { Button, TextInput } from '@payloadcms/ui';
+import { expectedConfirm, matchesConfirm } from '../../transitions/confirmPhrases.js';
+import { useApi } from '../useApi.js';
+import { reloadPage } from '../reload.js';
+import { ACTIONS_COPY as C } from '../copy/actions.js';
+import { API_MESSAGES } from '../copy/common.js';
+import { MakeContentResult } from './MakeContentResult.js';
+export function DialogFrame({ title, onClose, children }) {
+    const heading = useId();
+    const ref = useRef(null);
+    useEffect(()=>{
+        const previous = document.activeElement;
+        ref.current?.focus();
+        return ()=>{
+            if (previous instanceof HTMLElement && previous.isConnected) previous.focus();
+        };
+    }, []);
+    return /*#__PURE__*/ createPortal(/*#__PURE__*/ _jsx("div", {
+        style: {
+            position: 'fixed',
+            inset: 0,
+            zIndex: 1000,
+            background: 'var(--theme-overlay)',
+            display: 'grid',
+            placeItems: 'center'
+        },
+        children: /*#__PURE__*/ _jsxs("div", {
+            ref: ref,
+            role: "dialog",
+            "aria-modal": "true",
+            "aria-labelledby": heading,
+            tabIndex: -1,
+            style: {
+                background: 'var(--theme-bg)',
+                color: 'var(--theme-text)',
+                border: '1px solid var(--theme-elevation-200)',
+                padding: '2rem',
+                width: 'min(36rem, 90vw)',
+                maxHeight: '90vh',
+                overflow: 'auto',
+                borderRadius: 'var(--style-radius-s)'
+            },
+            onKeyDown: (event)=>{
+                if (event.defaultPrevented) return;
+                if (event.key === 'Escape') {
+                    event.preventDefault();
+                    event.stopPropagation();
+                    onClose();
+                }
+                if (event.key === 'Tab') {
+                    const items = Array.from(ref.current?.querySelectorAll('button:not(:disabled), input:not(:disabled), textarea:not(:disabled), select:not(:disabled), [tabindex="0"]') ?? []);
+                    const first = items[0], last = items.at(-1);
+                    if (!first) {
+                        event.preventDefault();
+                        ref.current?.focus();
+                    } else if (event.shiftKey && (document.activeElement === first || document.activeElement === ref.current)) {
+                        event.preventDefault();
+                        last?.focus();
+                    } else if (!event.shiftKey && (document.activeElement === last || document.activeElement === ref.current)) {
+                        event.preventDefault();
+                        first.focus();
+                    }
+                }
+            },
+            children: [
+                /*#__PURE__*/ _jsx("h2", {
+                    id: heading,
+                    children: title
+                }),
+                children
+            ]
+        })
+    }), document.body);
+}
+export function ConfirmDialog({ id, action, winnerLabel, onClose }) {
+    const api = useApi();
+    const [typed, setTyped] = useState('');
+    const [busy, setBusy] = useState(false);
+    const inFlight = useRef(false);
+    const [error, setError] = useState(null);
+    const [content, setContent] = useState(null);
+    const phrase = action.confirm.phrase ? expectedConfirm(action.confirm.phrase.action, winnerLabel) : null;
+    const enabled = !busy && (!phrase || matchesConfirm(phrase, typed));
+    async function submit() {
+        if (inFlight.current || !enabled) return;
+        inFlight.current = true;
+        setBusy(true);
+        setError(null);
+        let result;
+        if (action.archive) result = await api.archive(id, {
+            ...action.archive,
+            ...phrase ? {
+                confirmation: typed.trim()
+            } : {}
+        });
+        else if (action.id === 'start') result = await api.start(id);
+        else if (action.id === 'stop') result = await api.stop(id);
+        else if (action.id === 'release-holdout') result = await api.releaseHoldout(id);
+        else {
+            const response = await api.makeContent(id);
+            if (response.ok && response.data) {
+                setContent(response.data);
+                inFlight.current = false;
+                setBusy(false);
+                return;
+            }
+            result = response;
+        }
+        if (result.ok && action.id !== 'make-content') {
+            reloadPage();
+            return;
+        }
+        inFlight.current = false;
+        setBusy(false);
+        setError(!result.ok ? result : {
+            ok: false,
+            status: 0,
+            message: API_MESSAGES.unreadable,
+            retryable: true
+        });
+    }
+    function close() {
+        if (busy) return;
+        if (content) reloadPage();
+        onClose();
+    }
+    return /*#__PURE__*/ _jsxs(DialogFrame, {
+        title: action.confirm.title,
+        onClose: close,
+        children: [
+            content ? /*#__PURE__*/ _jsx(MakeContentResult, {
+                result: content,
+                onRetry: submit,
+                busy: busy
+            }) : /*#__PURE__*/ _jsxs(_Fragment, {
+                children: [
+                    /*#__PURE__*/ _jsx("p", {
+                        children: action.confirm.body
+                    }),
+                    phrase ? /*#__PURE__*/ _jsxs(_Fragment, {
+                        children: [
+                            /*#__PURE__*/ _jsxs("p", {
+                                children: [
+                                    C.typePhrase,
+                                    " ",
+                                    /*#__PURE__*/ _jsx("strong", {
+                                        children: phrase
+                                    })
+                                ]
+                            }),
+                            /*#__PURE__*/ _jsx(TextInput, {
+                                path: "xp-confirmation",
+                                hasMany: false,
+                                label: C.confirmation,
+                                value: typed,
+                                readOnly: busy,
+                                onChange: (event)=>setTyped(event.target.value)
+                            })
+                        ]
+                    }) : null
+                ]
+            }),
+            error ? /*#__PURE__*/ _jsx("p", {
+                role: "alert",
+                children: error.message
+            }) : null,
+            content ? null : /*#__PURE__*/ _jsx(Button, {
+                disabled: !enabled,
+                onClick: ()=>{
+                    void submit();
+                },
+                children: action.label
+            }),
+            error?.retryable ? /*#__PURE__*/ _jsx(Button, {
+                disabled: !enabled,
+                onClick: ()=>{
+                    void submit();
+                },
+                children: C.retry
+            }) : null,
+            /*#__PURE__*/ _jsx(Button, {
+                disabled: busy,
+                onClick: close,
+                children: content ? C.done : C.cancel
+            })
+        ]
+    });
+}

package/dist/admin/actions/DecideDialog.d.ts

@@ -0,0 +1,7 @@
+import type { DocId } from '../../types/contracts.js';
+import type { ActionGroup } from './actions.model.js';
+export declare function DecideDialog({ id, arms, onClose }: {
+    id: DocId;
+    arms: readonly ActionGroup[];
+    onClose: () => void;
+}): import("react").JSX.Element;

package/dist/admin/actions/DecideDialog.js

@@ -0,0 +1,173 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from 'react';
+import { Button, SelectInput, TextareaInput, TextInput } from '@payloadcms/ui';
+import { useApi } from '../useApi.js';
+import { reloadPage } from '../reload.js';
+import { ACTIONS_COPY as C, decideCopy } from '../copy/actions.js';
+import { decideState } from './decide.model.js';
+import { DialogFrame } from './ConfirmDialog.js';
+export function DecideDialog({ id, arms, onClose }) {
+    const api = useApi();
+    const [snapshot, setSnapshot] = useState(null);
+    const [chosenArm, setChosenArm] = useState(null);
+    const [note, setNote] = useState('');
+    const [typed, setTyped] = useState('');
+    const [loading, setLoading] = useState(true);
+    const [busy, setBusy] = useState(false);
+    const inFlight = useRef(false);
+    const refreshing = useRef(false);
+    const [error, setError] = useState(null);
+    const [loadFailed, setLoadFailed] = useState(false);
+    const state = decideState({
+        snapshot,
+        arms,
+        chosenArm,
+        note,
+        typed
+    });
+    useEffect(()=>{
+        let current = true;
+        void api.results(id).then((result)=>{
+            if (!current) return;
+            if (result.ok) {
+                const next = result.data?.snapshot ?? null;
+                setSnapshot(next);
+                setChosenArm(next?.verdict.recommendedArm ?? null);
+            } else {
+                setError(result);
+                setLoadFailed(true);
+            }
+            setLoading(false);
+        });
+        return ()=>{
+            current = false;
+        };
+    }, [
+        api,
+        id
+    ]);
+    async function refresh() {
+        if (refreshing.current) return;
+        refreshing.current = true;
+        setLoading(true);
+        const result = await api.results(id);
+        refreshing.current = false;
+        setLoading(false);
+        if (result.ok) {
+            setSnapshot(result.data?.snapshot ?? null);
+            setLoadFailed(false);
+        } else {
+            setSnapshot(null);
+            setError(result);
+            setLoadFailed(true);
+        }
+    }
+    async function submit() {
+        if (inFlight.current || loading || busy || !state.canSubmit || loadFailed) return;
+        inFlight.current = true;
+        setBusy(true);
+        setError(null);
+        const result = await api.decide(id, state.body);
+        if (result.ok) {
+            reloadPage();
+            return;
+        } else {
+            setError(result);
+            if (result.code === 'confirmation-required') {
+                setTyped('');
+                await refresh();
+            }
+        }
+        inFlight.current = false;
+        setBusy(false);
+    }
+    const enabled = !busy && !loading && !loadFailed && state.canSubmit;
+    const label = state.options.find((option)=>option.value === chosenArm)?.label;
+    return /*#__PURE__*/ _jsxs(DialogFrame, {
+        title: C.decide,
+        onClose: ()=>{
+            if (!busy) onClose();
+        },
+        children: [
+            loading ? /*#__PURE__*/ _jsx("p", {
+                role: "status",
+                children: C.loading
+            }) : null,
+            /*#__PURE__*/ _jsx(SelectInput, {
+                path: "xp-winner",
+                name: "xp-winner",
+                label: C.group,
+                options: state.options,
+                value: chosenArm ?? '',
+                readOnly: busy || loading,
+                required: true,
+                onChange: (option)=>{
+                    setChosenArm(option && !Array.isArray(option) ? String(option.value) : null);
+                    setTyped('');
+                }
+            }),
+            label ? /*#__PURE__*/ _jsx("p", {
+                children: decideCopy(label, arms.some((group)=>group.key === 'holdout'), chosenArm === 'control')
+            }) : null,
+            state.reason ? /*#__PURE__*/ _jsx("p", {
+                children: state.reason
+            }) : null,
+            /*#__PURE__*/ _jsx(TextareaInput, {
+                path: "xp-note",
+                label: C.note,
+                value: note,
+                required: state.guarded,
+                readOnly: busy,
+                onChange: (event)=>setNote(event.target.value)
+            }),
+            state.guarded && label ? /*#__PURE__*/ _jsxs(_Fragment, {
+                children: [
+                    /*#__PURE__*/ _jsxs("p", {
+                        children: [
+                            C.typePhrase,
+                            " ",
+                            /*#__PURE__*/ _jsx("strong", {
+                                children: state.phrase
+                            })
+                        ]
+                    }),
+                    /*#__PURE__*/ _jsx(TextInput, {
+                        path: "xp-decide-confirmation",
+                        hasMany: false,
+                        label: C.confirmation,
+                        value: typed,
+                        readOnly: busy,
+                        onChange: (event)=>setTyped(event.target.value)
+                    })
+                ]
+            }) : null,
+            error ? /*#__PURE__*/ _jsx("p", {
+                role: "alert",
+                children: error.message
+            }) : null,
+            /*#__PURE__*/ _jsx(Button, {
+                disabled: !enabled,
+                onClick: ()=>{
+                    void submit();
+                },
+                children: C.decide
+            }),
+            error?.retryable ? /*#__PURE__*/ _jsx(Button, {
+                disabled: busy || loading || !loadFailed && !state.canSubmit,
+                onClick: ()=>{
+                    if (loadFailed) {
+                        setError(null);
+                        void refresh();
+                    } else void submit();
+                },
+                children: C.retry
+            }) : null,
+            /*#__PURE__*/ _jsx(Button, {
+                disabled: busy,
+                onClick: onClose,
+                children: C.cancel
+            })
+        ]
+    });
+}

package/dist/admin/actions/ExperimentActions.d.ts

@@ -0,0 +1,3 @@
+import '../styles.js';
+import type { UIFieldClientProps } from 'payload';
+export declare function ExperimentActions(_props: UIFieldClientProps): import("react").JSX.Element | null;

package/dist/admin/actions/ExperimentActions.js

@@ -0,0 +1,110 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import '../styles.js';
+import { useState } from 'react';
+import { Button, useAuth, useDocumentInfo, useFormFields, useFormModified } from '@payloadcms/ui';
+import { canManage } from '../permissions.model.js';
+import { actionGroupLabel, availableActions } from './actions.model.js';
+import { ConfirmDialog } from './ConfirmDialog.js';
+import { DecideDialog } from './DecideDialog.js';
+import { ACTIONS_COPY } from '../copy/actions.js';
+import { AllocateDialog } from './AllocateDialog.js';
+import { AddMetricDialog } from './AddMetricDialog.js';
+const SAVE_FIRST = 'Save your changes first; these actions use the saved experiment.';
+export function ExperimentActions(_props) {
+    const { id } = useDocumentInfo();
+    const { permissions } = useAuth();
+    const status = useFormFields(([fields])=>fields.status?.value ?? 'draft');
+    const kind = useFormFields(([fields])=>fields.kind?.value ?? 'block');
+    // A primitive slice keeps unrelated form edits from rerendering this panel.
+    const groups = useFormFields(([fields])=>JSON.stringify(Object.keys(fields).filter((path)=>/^arms\.\d+\.(key|label|kind)$/.test(path)).sort().map((path)=>[
+                path,
+                fields[path]?.value
+            ])));
+    const armsByIndex = {};
+    for (const [path, value] of JSON.parse(groups)){
+        const [, index, field] = path.split('.');
+        const group = armsByIndex[index] ??= {
+            key: ''
+        };
+        group[field] = value;
+    }
+    const arms = Object.entries(armsByIndex).sort(([a], [b])=>Number(a) - Number(b)).map(([, group])=>group);
+    const winnerArm = useFormFields(([fields])=>fields['decision.winnerArm']?.value);
+    const holdoutReleasedAt = useFormFields(([fields])=>fields['decision.holdoutReleasedAt']?.value);
+    const contentReport = useFormFields(([fields])=>fields['decision.contentReport']?.value);
+    const allocation = useFormFields(([fields])=>fields.allocation?.value ?? 100);
+    const attachedMetricsJson = useFormFields(([fields])=>{
+        const relationId = (value)=>{
+            if (Array.isArray(value)) return value.flatMap(relationId);
+            if (typeof value === 'string' || typeof value === 'number') return [
+                value
+            ];
+            if (value && typeof value === 'object' && 'id' in value) return relationId(value.id);
+            return [];
+        };
+        return JSON.stringify([
+            'metrics.primary',
+            'metrics.secondary',
+            'metrics.guardrails'
+        ].flatMap((path)=>relationId(fields[path]?.value)));
+    });
+    const attachedMetrics = JSON.parse(attachedMetricsJson);
+    const [selected, setSelected] = useState(null);
+    // Transitions act on the saved document (and the typed phrase uses the saved group label), so unsaved edits block them.
+    const modified = useFormModified();
+    const actions = availableActions({
+        status,
+        kind,
+        arms,
+        decision: {
+            winnerArm,
+            holdoutReleasedAt,
+            contentReport
+        },
+        canManage: canManage(permissions)
+    });
+    const action = actions.find((candidate)=>candidate.id === selected);
+    if (id == null) return null;
+    const label = actionGroupLabel(winnerArm ?? 'control', arms.find((group)=>group.key === winnerArm)?.label);
+    return /*#__PURE__*/ _jsxs("div", {
+        className: "xp-actions",
+        children: [
+            modified && actions.length ? /*#__PURE__*/ _jsx("p", {
+                className: "xp-actions__note",
+                children: SAVE_FIRST
+            }) : null,
+            status === 'archived' || status === 'draft' ? /*#__PURE__*/ _jsx("p", {
+                className: "xp-actions__note",
+                children: status === 'archived' ? ACTIONS_COPY.deleteNoteArchived : ACTIONS_COPY.deleteNoteDraft
+            }) : null,
+            actions.map((item)=>/*#__PURE__*/ _jsx(Button, {
+                    buttonStyle: item.tone === 'primary' ? 'primary' : 'secondary',
+                    disabled: modified,
+                    className: `xp-action xp-action--${item.tone}`,
+                    onClick: ()=>{
+                        if (!modified) setSelected(item.id);
+                    },
+                    children: item.label
+                }, item.id)),
+            action?.id === 'allocate' ? /*#__PURE__*/ _jsx(AllocateDialog, {
+                id: id,
+                allocation: allocation,
+                onClose: ()=>setSelected(null)
+            }, `${id}/allocate`) : action?.id === 'add-metric' ? /*#__PURE__*/ _jsx(AddMetricDialog, {
+                id: id,
+                attachedMetrics: attachedMetrics,
+                onClose: ()=>setSelected(null)
+            }, `${id}/add-metric`) : action?.id === 'decide' ? /*#__PURE__*/ _jsx(DecideDialog, {
+                id: id,
+                arms: arms,
+                onClose: ()=>setSelected(null)
+            }, `${id}/decide`) : action ? /*#__PURE__*/ _jsx(ConfirmDialog, {
+                id: id,
+                action: action,
+                winnerLabel: label,
+                onClose: ()=>setSelected(null)
+            }, `${id}/${action.id}`) : null
+        ]
+    });
+}

package/dist/admin/actions/MakeContentResult.d.ts

@@ -0,0 +1,6 @@
+import type { MakeContentResult as Result } from '../../types/endpoints.js';
+export declare function MakeContentResult({ result, onRetry, busy }: {
+    result: Result;
+    onRetry: () => void | Promise<void>;
+    busy?: boolean;
+}): import("react").JSX.Element;

package/dist/admin/actions/MakeContentResult.js

@@ -0,0 +1,50 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useRef, useState } from 'react';
+import { Button } from '@payloadcms/ui';
+import { ACTIONS_COPY as C } from '../copy/actions.js';
+export function MakeContentResult({ result, onRetry, busy = false }) {
+    const inFlight = useRef(false);
+    const [pending, setPending] = useState(false);
+    async function retry() {
+        if (inFlight.current || busy) return;
+        inFlight.current = true;
+        setPending(true);
+        try {
+            await onRetry();
+        } finally{
+            inFlight.current = false;
+            setPending(false);
+        }
+    }
+    const failed = result.docs.some((doc)=>!doc.ok);
+    return /*#__PURE__*/ _jsxs("div", {
+        "aria-live": "polite",
+        children: [
+            /*#__PURE__*/ _jsx("ul", {
+                children: result.docs.map((doc, index)=>/*#__PURE__*/ _jsxs("li", {
+                        children: [
+                            'title' in doc && typeof doc.title === 'string' && doc.title || `${doc.collection}/${doc.id}`,
+                            ": ",
+                            doc.ok ? C.updated : C.failed,
+                            doc.error ? ` — ${doc.error}` : ''
+                        ]
+                    }, `${doc.collection}/${doc.id}/${index}`))
+            }),
+            failed ? /*#__PURE__*/ _jsxs(_Fragment, {
+                children: [
+                    /*#__PURE__*/ _jsx("p", {
+                        children: C.partial
+                    }),
+                    /*#__PURE__*/ _jsx(Button, {
+                        disabled: busy || pending,
+                        onClick: ()=>{
+                            void retry();
+                        },
+                        children: C.retry
+                    })
+                ]
+            }) : null
+        ]
+    });
+}

package/dist/admin/actions/actions.model.d.ts

@@ -0,0 +1,37 @@
+import type { ExperimentKind, Status } from '../../types/contracts.js';
+import type { ArchiveBody, MakeContentResult } from '../../types/endpoints.js';
+export type ActionGroup = {
+    key: string;
+    label?: string;
+    kind?: string;
+};
+export type ContentReport = {
+    docs: MakeContentResult['docs'];
+} | MakeContentResult['docs'];
+export type ActionDecision = {
+    winnerArm?: string | null;
+    holdoutReleasedAt?: string | null;
+    contentReport?: ContentReport | null;
+};
+export type ActionId = 'start' | 'stop' | 'decide' | 'release-holdout' | 'make-content' | 'after-content' | 'archive' | 'discard' | 'hard-coded' | 'allocate' | 'add-metric';
+export type ExperimentAction = {
+    id: ActionId;
+    label: string;
+    tone: 'primary' | 'secondary' | 'danger';
+    confirm: {
+        title: string;
+        body: string;
+        phrase?: {
+            action: 'discard' | 'hard-coded';
+        };
+    };
+    archive?: ArchiveBody;
+};
+export declare function actionGroupLabel(key: string, storedLabel?: string): string;
+export declare function availableActions({ status, kind, arms, decision, canManage }: {
+    status: Status;
+    kind: ExperimentKind;
+    arms: readonly ActionGroup[];
+    decision?: ActionDecision | null;
+    canManage: boolean;
+}): ExperimentAction[];