@delmaredigital/payload-experiments 0.3.0-rc.4 → 0.4.0-rc.2

package/dist/admin/surface/readiness/Banner.js

@@ -7,8 +7,10 @@ import { jumpToSection } from '../test/jumpToSection.js';
 import { actionGroupLabel, availableActions } from '../../actions/actions.model.js';
 import { createApi } from '../../api.js';
 import { READINESS_COPY as C, decidedCopy, nextCopy, runningCopy, stoppedCopy } from '../../copy/readiness.js';
-import { READINESS, daysRemaining, displayDate, nextStep } from './readiness.model.js';
+import { READINESS, daysRemaining, displayDate, nextStep, pageReadinessContext } from './readiness.model.js';
 import { AddMetricAction, AllocateAction, ConfirmAction } from './ActionDialogs.js';
+import { preflightPlacementLabel } from '../../placements/placementLabels.js';
+import { placementUncheckedCopy } from '../../copy/readiness.js';
 import { useTransition } from './useTransition.js';
 const RUNNING_ACTIONS = [
     'stop',
@@ -49,10 +51,17 @@ export function ReadinessContent({ test, surface, resultsVersion, bar = false })
     ]);
     const decision = doc.decision;
     const winner = actionGroupLabel(decision?.winnerArm ?? 'control', doc.arms.find((item)=>item.key === decision?.winnerArm)?.label);
-    const next = nextStep(test.preflight, {
-        ...doc,
-        flagPoints: surface.flagPoints
-    });
+    const labelledPreflight = test.preflight ? {
+        ...test.preflight,
+        checks: test.preflight.checks.map((check)=>check.code === 'placement-unchecked' ? {
+                ...check,
+                detail: {
+                    ...check.detail,
+                    title: preflightPlacementLabel(check.detail, test.preflight, surface.adminRoute).title
+                }
+            } : check)
+    } : null;
+    const next = nextStep(labelledPreflight, pageReadinessContext(doc, test.preflight, surface));
     const setup = doc.status === 'draft' || doc.status === 'stopped';
     const ready = Boolean(test.preflight && !test.preflightPending && !test.preflightError && test.preflight.checks.every((check)=>check.ok));
     const unsaved = test.hasUnsaved || test.saving === 'saving';
@@ -96,7 +105,7 @@ export function ReadinessContent({ test, surface, resultsVersion, bar = false })
                             href: `#section-${next.section}`,
                             onClick: (event)=>{
                                 event.preventDefault();
-                                if (next.section !== 'header') jumpToSection(next.section);
+                                if (next.section !== 'header') jumpToSection(next.section, next.arm);
                             },
                             children: [
                                 sentence,
@@ -119,6 +128,21 @@ export function ReadinessContent({ test, surface, resultsVersion, bar = false })
             test.preflight?.checks.filter((check)=>check.code === 'make-content-unsupported' && check.warning).map((check)=>/*#__PURE__*/ _jsx("p", {
                     children: READINESS[check.code].next(check.detail, doc)
                 }, check.code)),
+            test.preflight?.checks.filter((check)=>check.warning && [
+                    'goal-in-some-versions',
+                    'placement-unchecked'
+                ].includes(check.code)).map((check, index)=>{
+                const placement = check.code === 'placement-unchecked' ? preflightPlacementLabel(check.detail, test.preflight, surface.adminRoute) : undefined;
+                return /*#__PURE__*/ _jsx("p", {
+                    children: placement ? placement.href ? /*#__PURE__*/ _jsx("a", {
+                        href: placement.href,
+                        children: placementUncheckedCopy(placement.title)
+                    }) : placementUncheckedCopy(placement.title) : READINESS[check.code].next(check.detail, doc)
+                }, `${check.code}:${index}`);
+            }),
+            test.preflight?.goalNotes?.map((note)=>/*#__PURE__*/ _jsx("p", {
+                    children: note.message
+                }, note.metricId)),
             doc.status === 'stopped' ? /*#__PURE__*/ _jsx("p", {
                 children: stoppedCopy(displayDate(doc.stoppedAt))
             }) : null,

package/dist/admin/surface/readiness/readiness.model.d.ts

@@ -1,18 +1,22 @@
 import type { ReadinessCode, PreflightResult } from '../../../types/endpoints.js';
 import type { SerializedFlagPoint } from '../../../types/admin.js';
 import type { TestDocument } from '../testDocument.model.js';
+import type { SurfaceProps } from '../contracts.js';
 import { type SectionId } from '../contracts.js';
 export type ReadinessContext = Pick<TestDocument, 'arms' | 'unitType' | 'flagPoint'> & {
+    collectionLabel?: string;
+    pagePlacements?: PreflightResult['pagePlacements'];
     flagPoints?: readonly Pick<SerializedFlagPoint, 'id' | 'params'>[];
 };
 /** Exhaustive mapping of the checkStart ReadinessCode union, including all ten invariant checks. */
 export declare const READINESS: Record<ReadinessCode, {
     section: SectionId | 'header';
     next(detail: unknown, ctx: ReadinessContext): string | null;
-    nextStep?: string;
+    nextStep?: string | ((detail: unknown, ctx: ReadinessContext) => string);
 }>;
 export declare function nextStep(preflight: PreflightResult | null, ctx: ReadinessContext): {
     nextStep?: string | undefined;
+    arm?: import("../../../types/contracts.js").ArmKey | undefined;
     section: "header" | SectionId;
     sentence: string;
     code: ReadinessCode;
@@ -22,3 +26,6 @@ export declare function sectionDone(test: {
 }): Record<SectionId, boolean>;
 export declare function displayDate(value: unknown): string | null;
 export declare function daysRemaining(doc: TestDocument, now: number): number | null;
+export declare function pageReadinessContext(doc: TestDocument, preflight: PreflightResult | null, surface: SurfaceProps): ReadinessContext;
+/** First affected row in arm order; shared by the wizard and the test-page jump. */
+export declare function readinessArm(code: ReadinessCode, detail: unknown, ctx: ReadinessContext): import("../../../types/contracts.js").ArmKey | undefined;

package/dist/admin/surface/readiness/readiness.model.js

@@ -1,6 +1,9 @@
+import { SURFACE_COPY } from '../../copy/surface.js';
 import { formatDate } from '../../format/date.js';
 import { actionGroupLabel } from '../../actions/actions.model.js';
-import { unsupportedContentCopy, versionPageUnavailableCopy, versionPageUncheckedCopy, placementFailureCopy, pageInUseCopy, unpublishedPageCopy, READINESS_COPY as C, attributeNext, contentNext, goalPeopleNext, parameterNext, placementNext, ruleNext, versionsNext } from '../../copy/readiness.js';
+import { asymmetricGoalsCopy, placementUncheckedCopy, interactingTestsCopy, sameAddressCopy, identicalVersionCopy, unsupportedContentCopy, versionPageUnavailableCopy, versionPageUncheckedCopy, placementFailureCopy, pageInUseCopy, unpublishedPageCopy, READINESS_COPY as C, attributeNext, contentNext, goalPeopleNext, parameterNext, placementNext, ruleNext, versionsNext } from '../../copy/readiness.js';
+import { normalisePath } from '../../../runtime/normalisePath.js';
+import { testPageCollection } from '../pagePicker/pagePicker.model.js';
 import { SECTION_ORDER } from '../contracts.js';
 const object = (value)=>value && typeof value === 'object' && !Array.isArray(value) ? value : {};
 const first = (value)=>object(Array.isArray(value) ? value[0] : value);
@@ -17,8 +20,31 @@ const row = (section, next)=>({
 const versions = row('versions', (detail)=>versionsNext(detailText(detail, C.versionFallback)));
 /** Exhaustive mapping of the checkStart ReadinessCode union, including all ten invariant checks. */ export const READINESS = {
     'make-content-unsupported': row('header', (detail)=>unsupportedContentCopy(text(detail, 'This page'))),
+    'goal-in-some-versions': {
+        ...row('win', (detail)=>asymmetricGoalsCopy(detail)),
+        nextStep: 'Edit the versions'
+    },
+    'placement-unchecked': {
+        ...row('versions', (detail)=>placementUncheckedCopy(text(object(detail).title ?? object(detail).path, 'This page'))),
+        nextStep: (detail)=>`Open ${text(object(detail).title ?? object(detail).path, 'the page')}`
+    },
     'invalid-status': row('header', ()=>null),
     'no-placements': row('what', (detail)=>detail === undefined ? C.noPlacements : placementFailureCopy(detail)),
+    'placement-removed': row('what', ()=>C.placementRemoved),
+    'placement-unpublished': {
+        ...row('versions', (detail)=>(Array.isArray(detail) && detail.length ? detail : [
+                detail
+            ]).map((placement)=>`The block you're testing is only on a draft of ${text(object(placement).title, 'this page')}. Publish the page before you start.`).join('\n')),
+        nextStep: 'Publish the page'
+    },
+    'duplicate-version-row': {
+        ...row('versions', (detail)=>`The Experiment block on ${text(first(detail).title, 'this page')} has the same version twice. Remove one of them, then save.`),
+        nextStep: (detail)=>`Edit ${text(first(detail).title, 'this page')}`
+    },
+    'interacting-tests': {
+        ...row('versions', (detail)=>interactingTestsCopy(text(first(detail).path, 'this page'), text(first(detail).status, 'running'), text(first(detail).name, 'another test'), first(detail).version === true)),
+        nextStep: (detail)=>`Open ${text(first(detail).name, 'the test')}${first(detail).version === true ? `\nEdit ${text(first(detail).path, 'this page')}` : ''}`
+    },
     'empty-slot': row('versions', (detail, ctx)=>{
         const placements = Array.isArray(detail) ? detail : [];
         const missing = ctx.arms.find((item)=>item.kind !== 'holdout' && placements.some((placement)=>{
@@ -50,14 +76,39 @@ const versions = row('versions', (detail)=>versionsNext(detailText(detail, C.ver
     'layer-full': row('versions', ()=>C.full),
     'layer-unit-mismatch': row('header', ()=>C.differentPeople),
     'page-in-use': {
-        ...row('versions', (detail)=>{
+        ...row('versions', (detail, ctx)=>{
             const paths = object(detail).paths;
-            return pageInUseCopy(text(Array.isArray(paths) ? paths[0] : undefined, 'this page'));
+            const path = text(Array.isArray(paths) ? paths[0] : undefined, 'this page');
+            return pageInUseCopy(path, pageArm(path, ctx)?.kind === 'variant');
         }),
-        nextStep: C.chooseDifferentPage
+        nextStep: C.choosePages
+    },
+    'page-no-targets': {
+        ...row('versions', ()=>C.noTargets),
+        nextStep: 'Choose pages'
+    },
+    'unknown-collection': row('versions', ()=>"That page type isn't set up for tests."),
+    'version-identical': {
+        ...row('versions', (detail, ctx)=>identicalVersionCopy(text(object(detail).path, object(detail).title ? `${group(object(detail).arm, ctx)} on ${text(object(detail).title, 'this page')}` : group(object(detail).arm, ctx)))),
+        nextStep: (detail, ctx)=>`Edit ${text(object(detail).path, group(object(detail).arm, ctx))}`
+    },
+    'version-same-address': {
+        ...row('versions', (detail, ctx)=>sameAddressCopy(group(object(detail).arm, ctx), group(object(detail).otherArm, ctx), text(object(detail).path, 'this address'), ctx.collectionLabel)),
+        nextStep: 'Choose pages'
+    },
+    'page-target-unpublished': {
+        ...row('versions', (detail, ctx)=>{
+            const path = text(typeof detail === 'string' ? detail : object(detail).path, 'This page');
+            const arm = ctx.arms.find((item)=>item.key === object(detail).arm) ?? pageArm(path, ctx);
+            const placement = (arm ? ctx.pagePlacements?.find((entry)=>entry.arm === arm.key) : undefined) ?? ctx.pagePlacements?.find((entry)=>normalisePath(entry.path) === normalisePath(path));
+            return unpublishedPageCopy(path, ctx.pagePlacements && ctx.collectionLabel ? {
+                original: arm?.kind === 'control',
+                found: placement?.id != null && placement.published === false,
+                collection: ctx.collectionLabel
+            } : undefined);
+        }),
+        nextStep: C.choosePages
     },
-    'page-no-targets': row('versions', ()=>C.noTargets),
-    'page-target-unpublished': row('versions', (detail)=>unpublishedPageCopy(text(detail, 'This page'))),
     'page-targets-unchecked': row('versions', ()=>C.uncheckedPages),
     'version-page-unavailable': row('versions', (detail)=>versionPageUnavailableCopy(text(detail, 'This page'))),
     'version-page-unchecked': row('versions', (detail)=>versionPageUncheckedCopy(text(detail, 'This page'))),
@@ -91,15 +142,28 @@ export function nextStep(preflight, ctx) {
         ...SECTION_ORDER
     ]){
         for (const check of preflight?.checks ?? []){
+            if (!Object.hasOwn(READINESS, check.code)) {
+                if (!check.ok && section === SECTION_ORDER[0]) return {
+                    section,
+                    sentence: SURFACE_COPY.next,
+                    code: check.code
+                };
+                continue;
+            }
             const mapping = READINESS[check.code];
             if (check.ok || mapping.section !== section) continue;
             const sentence = mapping.next(check.detail, ctx);
+            const nextStep = typeof mapping.nextStep === 'function' ? mapping.nextStep(check.detail, ctx) : mapping.nextStep;
+            const arm = readinessArm(check.code, check.detail, ctx);
             if (sentence) return {
                 section,
                 sentence,
                 code: check.code,
-                ...mapping.nextStep ? {
-                    nextStep: mapping.nextStep
+                ...arm ? {
+                    arm
+                } : {},
+                ...nextStep ? {
+                    nextStep
                 } : {}
             };
         }
@@ -109,7 +173,7 @@ export function nextStep(preflight, ctx) {
 export function sectionDone(test) {
     return Object.fromEntries(SECTION_ORDER.map((section)=>[
             section,
-            test.preflight ? !test.preflight.checks.some((check)=>!check.ok && READINESS[check.code].section === section) : section === 'who' || section === 'advanced'
+            test.preflight ? !test.preflight.checks.some((check)=>!check.ok && (Object.hasOwn(READINESS, check.code) ? READINESS[check.code].section : SECTION_ORDER[0]) === section) : section === 'who' || section === 'advanced'
         ]));
 }
 export function displayDate(value) {
@@ -121,3 +185,22 @@ export function daysRemaining(doc, now) {
     const start = typeof doc.startedAt === 'string' ? Date.parse(doc.startedAt) : NaN;
     return typeof days === 'number' && days > 0 && Number.isFinite(start) ? Math.max(0, Math.ceil(days - (now - start) / 86_400_000)) : null;
 }
+function pageArm(path, ctx) {
+    return ctx.arms.find((arm)=>arm.pageTarget && normalisePath(arm.pageTarget) === normalisePath(path));
+}
+export function pageReadinessContext(doc, preflight, surface) {
+    return {
+        ...doc,
+        flagPoints: surface.flagPoints,
+        pagePlacements: preflight?.pagePlacements,
+        collectionLabel: testPageCollection(surface.pageCollections, doc, preflight?.pagePlacements)?.label
+    };
+}
+/** First affected row in arm order; shared by the wizard and the test-page jump. */ export function readinessArm(code, detail, ctx) {
+    if (code === 'version-same-address') return ctx.arms.find((arm)=>arm.key === object(detail).arm)?.key;
+    if (code === 'page-no-targets') return ctx.arms.find((arm)=>arm.kind !== 'holdout' && !arm.pageTarget)?.key;
+    const paths = code === 'page-in-use' ? object(detail).paths : code === 'page-target-unpublished' ? [
+        detail
+    ] : [];
+    return ctx.arms.find((arm)=>arm.kind !== 'holdout' && arm.pageTarget && Array.isArray(paths) && paths.some((path)=>typeof path === 'string' && normalisePath(path) === normalisePath(arm.pageTarget)))?.key;
+}

package/dist/admin/surface/results/ReleasePages.d.ts

@@ -8,7 +8,9 @@ export declare function ReleasePagesDialog({ id, apiRoute, onClose, onSuccess, o
     onRefusal(message: string): void;
 }): import("react").JSX.Element;
 /** An inaccessible or deleted author never hides the recorded release date. */
-export declare function PagesReleased({ decision, apiRoute }: {
+export declare function PagesReleased({ decision, apiRoute, userId, userCollection: collection }: {
     decision: PageReleaseDecision;
     apiRoute: string;
+    userId?: DocId;
+    userCollection?: string;
 }): import("react").JSX.Element;

package/dist/admin/surface/results/ReleasePages.js

@@ -1,7 +1,6 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useRef, useState } from 'react';
-import { useAuth, useConfig } from '@payloadcms/ui';
 import { Button } from '../../../ui/Button.js';
 import { Dialog } from '../../../ui/Dialog.js';
 import { createApi } from '../../api.js';
@@ -63,10 +62,7 @@ export function ReleasePagesDialog({ id, apiRoute, onClose, onSuccess, onRefusal
         ]
     });
 }
-/** An inaccessible or deleted author never hides the recorded release date. */ export function PagesReleased({ decision, apiRoute }) {
-    const { user } = useAuth();
-    const { config } = useConfig();
-    const collection = config.admin.user;
+/** An inaccessible or deleted author never hides the recorded release date. */ export function PagesReleased({ decision, apiRoute, userId, userCollection: collection }) {
     const by = decision.pagesReleasedBy;
     const [resolved, setResolved] = useState(null);
     const key = JSON.stringify([
@@ -74,7 +70,7 @@ export function ReleasePagesDialog({ id, apiRoute, onClose, onSuccess, onRefusal
         collection,
         by
     ]);
-    const own = pagesReleasedBy(by, user?.id);
+    const own = pagesReleasedBy(by, userId);
     useEffect(()=>{
         if (!by || own || !collection) return;
         const controller = new AbortController();
@@ -109,7 +105,7 @@ export function ReleasePagesDialog({ id, apiRoute, onClose, onSuccess, onRefusal
         key,
         own
     ]);
-    const name = own ?? pagesReleasedBy(by, user?.id, resolved?.key === key ? resolved.author : null);
+    const name = own ?? pagesReleasedBy(by, userId, resolved?.key === key ? resolved.author : null);
     return /*#__PURE__*/ _jsx("p", {
         children: pagesReleasedCopy(formatDate(decision.pagesReleasedAt), name)
     });

package/dist/admin/surface/results/ResultsBody.js

@@ -27,6 +27,7 @@ import { DecideDialog } from '../../actions/DecideDialog.js';
 import { Banner } from '../../../ui/Banner.js';
 import { canReleasePages } from '../../results/releasePages.model.js';
 import { PagesReleased, ReleasePagesDialog } from './ReleasePages.js';
+import { usePlacementLabels } from '../../placements/usePlacementLabels.js';
 export function ResultsBody({ id, surface, onRecomputed, onPagesReleased, renderPage }) {
     // A different test owns an independent selection and action lifecycle.
     return /*#__PURE__*/ _jsx(ResultsContent, {
@@ -116,12 +117,20 @@ function ResultsContent({ id, surface, onRecomputed, onPagesReleased, renderPage
         isDecidedTestRound,
         winnerLabel: winner
     }) : null;
+    const placementLabels = usePlacementLabels({
+        details: shown?.health?.filter((item)=>item.code === 'placement-unchecked').map((item)=>item.detail) ?? [],
+        apiRoute: surface.apiRoute,
+        adminRoute: surface.adminRoute,
+        canManage: manage,
+        collectionTitles: surface.collectionTitles
+    });
     const context = {
         status,
         phase,
         inLayer: doc?.layer != null,
         layerSlices: doc?.layerSlices,
-        allocation: doc?.allocation
+        allocation: doc?.allocation,
+        placementLabels
     };
     const primary = phase?.metrics.find((metric)=>metric.role === 'primary');
     // The endpoint decides the current round; historical rounds are read-only.
@@ -147,7 +156,9 @@ function ResultsContent({ id, surface, onRecomputed, onPagesReleased, renderPage
     // Release details come only from the manager's own document, never the results response.
     const released = manage && doc?.decision?.pagesReleasedAt ? /*#__PURE__*/ _jsx(PagesReleased, {
         decision: doc.decision,
-        apiRoute: surface.apiRoute
+        apiRoute: surface.apiRoute,
+        userId: surface.userId,
+        userCollection: surface.userCollection
     }) : null;
     const meta = /*#__PURE__*/ _jsxs(_Fragment, {
         children: [
@@ -263,6 +274,9 @@ function ResultsContent({ id, surface, onRecomputed, onPagesReleased, renderPage
                         }, context),
                         sinceShipping: rolloutLine(shown, phase, phases, decision ?? undefined)
                     }),
+                    primary?.clickGoal ? /*#__PURE__*/ _jsx("p", {
+                        children: C.clickPrimary
+                    }) : null,
                     /*#__PURE__*/ _jsxs("div", {
                         className: "xp-stat-tiles",
                         children: [
@@ -309,6 +323,9 @@ function ResultsContent({ id, surface, onRecomputed, onPagesReleased, renderPage
                             })
                         ]
                     }) : null,
+                    shown.goalFairnessNotice ? /*#__PURE__*/ _jsx("p", {
+                        children: shown.goalFairnessNotice
+                    }) : null,
                     /*#__PURE__*/ _jsx(DataQualityPanel, {
                         problem: shown.verdict.code === 'data-problem',
                         items: dataQuality(shown, context)
@@ -340,6 +357,7 @@ function ResultsContent({ id, surface, onRecomputed, onPagesReleased, renderPage
                         })
                     }),
                     /*#__PURE__*/ _jsx(PreviewLinks, {
+                        apiRoute: surface.apiRoute,
                         experimentId: id,
                         flagPoint: doc?.flagPoint,
                         placements: placements,
@@ -360,6 +378,7 @@ function ResultsContent({ id, surface, onRecomputed, onPagesReleased, renderPage
                 ]
             }) : null,
             deciding && manage && phase ? /*#__PURE__*/ _jsx(DecideDialog, {
+                apiRoute: surface.apiRoute,
                 id: id,
                 arms: phase.arms,
                 checks: checks,

package/dist/admin/surface/results/ResultsHeader.js

@@ -1,5 +1,6 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { surfaceUrls } from '../../surfaceUrls.js';
 import { useEffect, useState } from 'react';
 import { formatAdminURL } from 'payload/shared';
 import { SurfaceShell } from '../SurfaceShell.js';
@@ -8,7 +9,7 @@ import { Banner, StatusChip } from '../../../ui/Feedback.js';
 import { createApi } from '../../api.js';
 import { availableActions, actionGroupLabel } from '../../actions/actions.model.js';
 import { AllocateAction, ConfirmAction } from '../readiness/ActionDialogs.js';
-import { READINESS, daysRemaining, displayDate, nextStep } from '../readiness/readiness.model.js';
+import { READINESS, daysRemaining, displayDate, nextStep, pageReadinessContext } from '../readiness/readiness.model.js';
 import { READINESS_COPY as R, runningCopy, stoppedCopy, decidedCopy } from '../../copy/readiness.js';
 import { RESULTS_COPY as C } from '../../copy/results.js';
 import { TEST_PAGE } from '../../copy/testPage.js';
@@ -54,10 +55,7 @@ export function ResultsHeader({ test, surface, resultsVersion, children, actions
             'allocate',
             'stop'
         ].indexOf(b.id) : 0);
-    const next = nextStep(test.preflight, {
-        ...doc,
-        flagPoints: surface.flagPoints
-    });
+    const next = nextStep(test.preflight, pageReadinessContext(doc, test.preflight, surface));
     const ready = Boolean(test.preflight && !test.preflightPending && !test.preflightError && test.preflight.checks.every((check)=>check.ok));
     const startReason = next?.sentence ?? (!ready ? test.preflightError ? R.checkError : R.checking : undefined);
     const action = available.find((item)=>item.id === selected);
@@ -72,10 +70,7 @@ export function ResultsHeader({ test, surface, resultsVersion, children, actions
         crumbs: [
             {
                 label: C.tests,
-                href: formatAdminURL({
-                    adminRoute: surface.adminRoute,
-                    path: '/experiments'
-                })
+                href: surface.canManage ? surfaceUrls.home(surface.adminRoute) : undefined
             },
             {
                 label: doc.name,
@@ -160,10 +155,7 @@ export function ReaderResultsShell({ surface, children, data }) {
         crumbs: [
             {
                 label: C.tests,
-                href: formatAdminURL({
-                    adminRoute: surface.adminRoute,
-                    path: '/experiments'
-                })
+                href: surface.canManage ? surfaceUrls.home(surface.adminRoute) : undefined
             },
             {
                 label: title

package/dist/admin/surface/results/useResults.d.ts

@@ -29,17 +29,34 @@ export declare function useResults(id: DocId, { apiRoute, canReadResults, canMan
     canManage?: boolean;
 }): {
     api: {
+        findTestIdBySlug: (slug: string) => Promise<Extract<ApiResult<DocId>, {
+            ok: false;
+        }> | {
+            ok: true;
+            data: DocId;
+        }>;
+        deleteTest: (id: DocId) => Promise<ApiResult<unknown>>;
+        wrapBlock: (body: import("../../../types/endpoints.js").WrapBlockBody) => Promise<ApiResult<Record<string, unknown>>>;
+        pages: (query: {
+            collection: string;
+            q?: string;
+            path?: string;
+            page?: number;
+        }, signal?: AbortSignal) => Promise<ApiResult<import("../../../types/endpoints.js").PagesResult>>;
+        placementStatus: (body: import("../../../types/endpoints.js").PlacementStatusBody) => Promise<ApiResult<import("../../../types/endpoints.js").PlacementStatusResult>>;
         start: (id: DocId) => Promise<ApiResult<import("../../../types/endpoints.js").TransitionSuccess>>;
         allocate: (id: DocId, body: import("../../../types/endpoints.js").AllocateBody, options?: {
             notFound?: string;
+            forbidden?: string;
             codes?: Readonly<Record<string, string>>;
             fallback?: string;
         }) => Promise<ApiResult<import("../../../types/endpoints.js").TransitionSuccess>>;
         addMetric: (id: DocId, body: import("../../../types/endpoints.js").AddMetricBody, options?: {
             notFound?: string;
+            forbidden?: string;
             codes?: Readonly<Record<string, string>>;
             fallback?: string;
-        }) => Promise<ApiResult<import("../../../types/endpoints.js").TransitionSuccess>>;
+        }) => Promise<ApiResult<import("../../../types/endpoints.js").AddMetricResult>>;
         stop: (id: DocId) => Promise<ApiResult<import("../../../types/endpoints.js").TransitionSuccess>>;
         decide: (id: DocId, body: import("../../../types/endpoints.js").DecideBody) => Promise<ApiResult<import("../../../types/endpoints.js").TransitionSuccess>>;
         releaseHoldout: (id: DocId) => Promise<ApiResult<import("../../../types/endpoints.js").TransitionSuccess>>;
@@ -48,6 +65,7 @@ export declare function useResults(id: DocId, { apiRoute, canReadResults, canMan
         dismissContentEntry: (id: DocId, body: import("../../../types/endpoints.js").DismissContentEntryBody) => Promise<ApiResult<import("../../../types/endpoints.js").DismissContentEntryResult>>;
         restoreContentEntry: (id: DocId, body: import("../../../types/endpoints.js").RestoreContentEntryBody) => Promise<ApiResult<import("../../../types/endpoints.js").RestoreContentEntryResult>>;
         archive: (id: DocId, body: import("../../../types/endpoints.js").ArchiveBody) => Promise<ApiResult<import("../../../types/endpoints.js").TransitionSuccess>>;
+        clickKeys: (id: DocId) => Promise<ApiResult<import("../../../types/endpoints.js").ClickKeysResult>>;
         preflight: (id: DocId) => Promise<ApiResult<import("../../../types/endpoints.js").PreflightResult>>;
         previewToken: (id: DocId, arm: string) => Promise<ApiResult<import("../../../types/endpoints.js").PreviewTokenResult>>;
         results: (id: DocId, options?: {
@@ -55,6 +73,7 @@ export declare function useResults(id: DocId, { apiRoute, canReadResults, canMan
             series?: boolean;
         } & {
             notFound?: string;
+            forbidden?: string;
             codes?: Readonly<Record<string, string>>;
             fallback?: string;
         }) => Promise<ApiResult<ResultsResponse>>;