Skip to content

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

feat(builder): ask for required actions before publishing (#15954)

Abduldcebeca5ba18
diff --git a/packages/web/public/locales/en/translation.json b/packages/web/public/locales/en/translation.json
index bd41c0de91f..884b733c891 100644
--- a/packages/web/public/locales/en/translation.json
+++ b/packages/web/public/locales/en/translation.json
@@ -1,4 +1,6 @@
{
+ "You must include these actions to publish.": "You must include these actions to publish.",
+ "You must include one of these actions to publish.": "You must include one of these actions to publish.",
"At least one": "At least one",
"No required actions": "No required actions",
"Choose actions that flows in projects assigned to this set must include before they can publish.": "Choose actions that flows in projects assigned to this set must include before they can publish.",
diff --git a/packages/web/src/app/builder/flow-canvas/widgets/publish-flow-reminder-widget.tsx b/packages/web/src/app/builder/flow-canvas/widgets/publish-flow-reminder-widget.tsx
index 0954f881a45..1d08c6ec741 100644
--- a/packages/web/src/app/builder/flow-canvas/widgets/publish-flow-reminder-widget.tsx
+++ b/packages/web/src/app/builder/flow-canvas/widgets/publish-flow-reminder-widget.tsx
@@ -8,6 +8,7 @@ import {
import { useMutation } from '@tanstack/react-query';
import { t } from 'i18next';
import { Info } from 'lucide-react';
+import { useState } from 'react';
import { RightSideBarType } from '@/app/builder/types';
import { LoadingSpinner } from '@/components/custom/spinner';
@@ -26,6 +27,11 @@ import { useBuilderStateContext } from '../../builder-hooks';
import { runDiscard } from './discard-draft';
import LargeWidgetWrapper from './large-widget-wrapper';
+import {
+ FailedRequiredActionsCheck,
+ RequiredActionsDialog,
+ useRequiredActionsCheck,
+} from './required-actions-dialog';
const PublishFlowReminderWidget = () => {
const [
@@ -79,6 +85,10 @@ const PublishFlowReminderWidget = () => {
}),
},
);
+ const { checkRequiredActions, explainServerRejection } =
+ useRequiredActionsCheck();
+ const [failedRequiredActionsCheck, setFailedRequiredActionsCheck] =
+ useState<FailedRequiredActionsCheck | null>(null);
const { mutateAsync: publish } = flowHooks.useChangeFlowStatus({
flowId: flow.id,
change: 'publish',
@@ -87,7 +97,22 @@ const PublishFlowReminderWidget = () => {
setVersion(updatedFlow.version);
},
setIsPublishing: setIsPublishing,
+ onRequiredActionsMissing: (params) => {
+ explainServerRejection(params)
+ .then(setFailedRequiredActionsCheck)
+ .catch(() => undefined);
+ },
});
+ const handlePublish = async () => {
+ setIsPublishing(true);
+ const failedCheck = await checkRequiredActions(flowVersion);
+ if (failedCheck) {
+ setIsPublishing(false);
+ setFailedRequiredActionsCheck(failedCheck);
+ return;
+ }
+ await publish();
+ };
const { mutateAsync: overWriteDraftWithVersion } =
flowHooks.useOverWriteDraftWithVersion({
onSuccess: (updatedFlow) => {
@@ -136,7 +161,7 @@ const PublishFlowReminderWidget = () => {
loading={isSaving}
//for e2e tests
name="Publish"
- onClick={() => publish()}
+ onClick={handlePublish}
disabled={!isValid}
>
{requiresApproval ? t('Request approval') : t('Publish')}
@@ -150,6 +175,10 @@ const PublishFlowReminderWidget = () => {
</Tooltip>
</div>
)}
+ <RequiredActionsDialog
+ failedCheck={failedRequiredActionsCheck}
+ onClose={() => setFailedRequiredActionsCheck(null)}
+ />
</LargeWidgetWrapper>
);
};
diff --git a/packages/web/src/app/builder/flow-canvas/widgets/required-actions-dialog.tsx b/packages/web/src/app/builder/flow-canvas/widgets/required-actions-dialog.tsx
new file mode 100644
index 00000000000..4a6729e0ec7
--- /dev/null
+++ b/packages/web/src/app/builder/flow-canvas/widgets/required-actions-dialog.tsx
@@ -0,0 +1,521 @@
+import {
+ isNil,
+ RequiredActionsMissingErrorParams,
+ tryCatch,
+ unique,
+} from '@activepieces/core-utils';
+import { PieceMetadataModel } from '@activepieces/pieces-framework';
+import {
+ FlowActionType,
+ FlowOperationType,
+ FlowVersion,
+ RequiredActionsCheckResult,
+ RequiredActionsMode,
+ requiredActionsUtil,
+ StepLocationRelativeToParent,
+} from '@activepieces/shared';
+import { QueryClient, useQueryClient } from '@tanstack/react-query';
+import { useReactFlow } from '@xyflow/react';
+import { t } from 'i18next';
+import { useState } from 'react';
+import { useTranslation } from 'react-i18next';
+
+import {
+ BuilderState,
+ useBuilderStateContext,
+} from '@/app/builder/builder-hooks';
+import { getLastLocationAsPasteLocation } from '@/app/builder/flow-canvas/utils/bulk-actions';
+import { flowCanvasUtils } from '@/app/builder/flow-canvas/utils/flow-canvas-utils';
+import { Badge } from '@/components/ui/badge';
+import { Button } from '@/components/ui/button';
+import { Checkbox } from '@/components/ui/checkbox';
+import {
+ Dialog,
+ DialogContent,
+ DialogDescription,
+ DialogFooter,
+ DialogHeader,
+ DialogTitle,
+} from '@/components/ui/dialog';
+import { ScrollArea } from '@/components/ui/scroll-area';
+import {
+ pieceSetQueryOptions,
+ RequiredActionGroupHeader,
+} from '@/features/piece-sets';
+import { pieceQueryOptions, stepUtils } from '@/features/pieces';
+import { projectCollectionUtils } from '@/features/projects';
+import { platformHooks } from '@/hooks/platform-hooks';
+import { cn } from '@/lib/utils';
+
+export function useRequiredActionsCheck() {
+ const queryClient = useQueryClient();
+ const { i18n } = useTranslation();
+ const { platform } = platformHooks.useCurrentPlatform();
+ const { project } = projectCollectionUtils.useCurrentProject();
+
+ const checkRequiredActions = async (
+ flowVersion: FlowVersion,
+ ): Promise<FailedRequiredActionsCheck | null> => {
+ if (!platform.plan.managePiecesEnabled) {
+ return null;
+ }
+ const { data } = await tryCatch(() =>
+ loadAndCheckRequiredActions({
+ queryClient,
+ projectId: project.id,
+ language: i18n.language,
+ flowVersion,
+ }),
+ );
+ return data ?? null;
+ };
+
+ const explainServerRejection = async (
+ params: RequiredActionsMissingErrorParams['params'],
+ ): Promise<FailedRequiredActionsCheck> => {
+ const result = toCheckResult(params);
+ const pieceNames = unique([
+ ...Object.keys(result.missingActions),
+ ...Object.keys(result.skippedActions),
+ ]);
+ const piecesByName = await loadPiecesByName({
+ queryClient,
+ pieceNames,
+ language: i18n.language,
+ });
+ return { result, piecesByName };
+ };
+
+ return { checkRequiredActions, explainServerRejection };
+}
+
+export function RequiredActionsDialog({
+ failedCheck,
+ onClose,
+}: {
+ failedCheck: FailedRequiredActionsCheck | null;
+ onClose: () => void;
+}) {
+ return (
+ <Dialog
+ open={failedCheck !== null}
+ onOpenChange={(open) => !open && onClose()}
+ >
+ <DialogContent className="sm:max-w-md">
+ {failedCheck && (
+ <RequiredActionsDialogContent
+ failedCheck={failedCheck}
+ onClose={onClose}
+ />
+ )}
+ </DialogContent>
+ </Dialog>
+ );
+}
+
+function RequiredActionsDialogContent({
+ failedCheck,
+ onClose,
+}: {
+ failedCheck: FailedRequiredActionsCheck;
+ onClose: () => void;
+}) {
+ const { result, piecesByName } = failedCheck;
+ const { fitView } = useReactFlow();
+ const [flowVersion, handleAddingOrUpdatingStep] = useBuilderStateContext(
+ (state) => [state.flowVersion, state.handleAddingOrUpdatingStep],
+ );
+ const areAllActionsRequired = result.mode === RequiredActionsMode.ALL;
+ const missingRequiredActionsGroupedByPiece = buildMissingRequiredActionGroups(
+ {
+ result,
+ piecesByName,
+ },
+ );
+ const missingRequiredActions = missingRequiredActionsGroupedByPiece.flatMap(
+ (group) => group.actions,
+ );
+ const [requiredActionsToAdd, setRequiredActionsToAdd] = useState<
+ Record<string, string[]>
+ >(() =>
+ groupByPiece(
+ areAllActionsRequired
+ ? missingRequiredActions
+ : missingRequiredActions.slice(0, 1),
+ ),
+ );
+ const missingRequiredActionsToAdd = missingRequiredActions.filter((action) =>
+ willBeAdded({ requiredActionsToAdd, action }),
+ );
+
+ const toggleRequiredActionToAdd = (action: MissingRequiredAction) =>
+ setRequiredActionsToAdd((prev) =>
+ toggleRequiredAction({ requiredActionsToAdd: prev, action }),
+ );
+
+ const [showNoActionError, setShowNoActionError] = useState(false);
+
+ const addSteps = () => {
+ if (missingRequiredActionsToAdd.length === 0) {
+ setShowNoActionError(true);
+ return;
+ }
+ const addedStepNames = addRequiredSteps({
+ requiredActions: missingRequiredActionsToAdd,
+ piecesByName,
+ firstParentStepName:
+ getLastLocationAsPasteLocation(flowVersion).parentStepName,
+ addStep: handleAddingOrUpdatingStep,
+ });
+ const firstAddedStepName = addedStepNames[0];
+ if (firstAddedStepName) {
+ setTimeout(() =>
+ fitView(
+ flowCanvasUtils.createFocusStepInGraphParams(firstAddedStepName),
+ ),
+ );
+ }
+ onClose();
+ };
+
+ return (
+ <>
+ <DialogHeader>
+ <DialogTitle>
+ {areAllActionsRequired
+ ? t('Add required actions')
+ : t('Add a required action')}
+ </DialogTitle>
+ <DialogDescription>
+ {areAllActionsRequired
+ ? t('You must include these actions to publish.')
+ : t('You must include one of these actions to publish.')}
+ </DialogDescription>
+ </DialogHeader>
+ <ScrollArea viewPortClassName="max-h-96">
+ <div className="flex flex-col gap-3">
+ {missingRequiredActionsGroupedByPiece.map((group) => (
+ <div key={group.pieceName} className="flex flex-col">
+ <RequiredActionGroupHeader
+ displayName={group.displayName}
+ logoUrl={group.logoUrl}
+ />
+ {group.actions.map((action) =>
+ areAllActionsRequired ? (
+ <RequiredActionRow key={action.actionName} action={action} />
+ ) : (
+ <SelectableRequiredActionRow
+ key={action.actionName}
+ action={action}
+ checked={willBeAdded({ requiredActionsToAdd, action })}
+ onToggle={() => toggleRequiredActionToAdd(action)}
+ />
+ ),
+ )}
+ </div>
+ ))}
+ </div>
+ </ScrollArea>
+ {showNoActionError && missingRequiredActionsToAdd.length === 0 && (
+ <p className="text-sm font-medium text-danger-11">
+ {t('Select at least one action to add.')}
+ </p>
+ )}
+ <DialogFooter>
+ <Button type="button" variant="outline" onClick={onClose}>
+ {t('Cancel')}
+ </Button>
+ <Button type="button" onClick={addSteps}>
+ {t('addActionsCount', { count: missingRequiredActionsToAdd.length })}
+ </Button>
+ </DialogFooter>
+ </>
+ );
+}
+
+async function loadAndCheckRequiredActions({
+ queryClient,
+ projectId,
+ language,
+ flowVersion,
+}: {
+ queryClient: QueryClient;
+ projectId: string;
+ language: string;
+ flowVersion: FlowVersion;
+}): Promise<FailedRequiredActionsCheck | null> {
+ const pieceSet = await queryClient.fetchQuery(
+ pieceSetQueryOptions.project(projectId),
+ );
+ const { requiredActions } = pieceSet.config;
+ const pieceNames = Object.keys(requiredActions.actions);
+ if (pieceNames.length === 0) {
+ return null;
+ }
+ const piecesByName = await loadPiecesByName({
+ queryClient,
+ pieceNames,
+ language,
+ });
+ const actionExists = buildActionExistence({
+ requiredActions: requiredActions.actions,
+ piecesByName,
+ });
+ const result = requiredActionsUtil.checkRequiredActionsExistInFlowVersion({
+ requiredActions,
+ flowVersion,
+ actionExists,
+ });
+ return result.passed ? null : { result, piecesByName };
+}
+
+async function loadPiecesByName({
+ queryClient,
+ pieceNames,
+ language,
+}: {
+ queryClient: QueryClient;
+ pieceNames: string[];
+ language: string;
+}): Promise<Map<string, PieceMetadataModel>> {
+ const loadedPieces = await Promise.all(
+ pieceNames.map((name) => loadLatestPiece({ queryClient, name, language })),
+ );
+ const pieces = loadedPieces.filter((piece) => !isNil(piece));
+ return new Map(pieces.map((piece) => [piece.name, piece]));
+}
+
+function toCheckResult(
+ params: RequiredActionsMissingErrorParams['params'],
+): RequiredActionsCheckResult {
+ const mode =
+ params.mode === RequiredActionsMode.ALL
+ ? RequiredActionsMode.ALL
+ : RequiredActionsMode.ANY;
+ return {
+ passed: false,
+ mode,
+ requiredActions: params.requiredActions,
+ missingActions: params.missingActions,
+ skippedActions: params.skippedActions,
+ };
+}
+
+async function loadLatestPiece({
+ queryClient,
+ name,
+ language,
+}: {
+ queryClient: QueryClient;
+ name: string;
+ language: string;
+}): Promise<PieceMetadataModel | undefined> {
+ const { data } = await tryCatch(() =>
+ queryClient.ensureQueryData(pieceQueryOptions.latest({ name, language })),
+ );
+ return data ?? undefined;
+}
+
+function buildActionExistence({
+ requiredActions,
+ piecesByName,
+}: {
+ requiredActions: Record<string, string[]>;
+ piecesByName: Map<string, PieceMetadataModel>;
+}): Record<string, Record<string, boolean>> {
+ const existencePerPiece = Object.entries(requiredActions).map(
+ ([pieceName, actionNames]) => {
+ const piece = piecesByName.get(pieceName);
+ const existencePerAction = actionNames.map((actionName) => [
+ actionName,
+ !isNil(piece?.actions[actionName]),
+ ]);
+ return [pieceName, Object.fromEntries(existencePerAction)];
+ },
+ );
+ return Object.fromEntries(existencePerPiece);
+}
+
+function RequiredActionRow({ action }: { action: MissingRequiredAction }) {
+ return (
+ <div className="flex min-h-10 items-center gap-3 py-1.5 pl-9">
+ <RequiredActionName action={action} />
+ </div>
+ );
+}
+
+function SelectableRequiredActionRow({
+ action,
+ checked,
+ onToggle,
+}: {
+ action: MissingRequiredAction;
+ checked: boolean;
+ onToggle: () => void;
+}) {
+ return (
+ <label className="flex min-h-10 cursor-pointer items-center gap-3 py-1.5 pl-1">
+ <Checkbox checked={checked} onCheckedChange={onToggle} />
+ <RequiredActionName action={action} className="pl-2" />
+ </label>
+ );
+}
+
+function RequiredActionName({
+ action,
+ className,
+}: {
+ action: MissingRequiredAction;
+ className?: string;
+}) {
+ return (
+ <>
+ <span className={cn('flex-1 text-sm', className)}>
+ {action.displayName}
+ </span>
+ {action.skipped && (
+ <Badge variant="outline" className="shrink-0">
+ {t('Skipped')}
+ </Badge>
+ )}
+ </>
+ );
+}
+
+function buildMissingRequiredActionGroups({
+ result,
+ piecesByName,
+}: {
+ result: RequiredActionsCheckResult;
+ piecesByName: Map<string, PieceMetadataModel>;
+}): MissingRequiredActionGroup[] {
+ const pieceNames = unique([
+ ...Object.keys(result.missingActions),
+ ...Object.keys(result.skippedActions),
+ ]);
+ return pieceNames.map((pieceName) => {
+ const piece = piecesByName.get(pieceName);
+ const skippedActionNames = result.skippedActions[pieceName] ?? [];
+ const actionNames = [
+ ...(result.missingActions[pieceName] ?? []),
+ ...skippedActionNames,
+ ];
+ return {
+ pieceName,
+ displayName: piece?.displayName ?? pieceName,
+ logoUrl: piece?.logoUrl,
+ actions: actionNames.map((actionName) => ({
+ pieceName,
+ actionName,
+ displayName: piece?.actions[actionName]?.displayName ?? actionName,
+ skipped: skippedActionNames.includes(actionName),
+ })),
+ };
+ });
+}
+
+function groupByPiece(
+ actions: MissingRequiredAction[],
+): Record<string, string[]> {
+ return actions.reduce<Record<string, string[]>>(
+ (actionsByPiece, action) => ({
+ ...actionsByPiece,
+ [action.pieceName]: [
+ ...(actionsByPiece[action.pieceName] ?? []),
+ action.actionName,
+ ],
+ }),
+ {},
+ );
+}
+
+function willBeAdded({
+ requiredActionsToAdd,
+ action,
+}: {
+ requiredActionsToAdd: Record<string, string[]>;
+ action: MissingRequiredAction;
+}): boolean {
+ return (
+ requiredActionsToAdd[action.pieceName]?.includes(action.actionName) ?? false
+ );
+}
+
+function toggleRequiredAction({
+ requiredActionsToAdd,
+ action,
+}: {
+ requiredActionsToAdd: Record<string, string[]>;
+ action: MissingRequiredAction;
+}): Record<string, string[]> {
+ const actionNamesInPiece = requiredActionsToAdd[action.pieceName] ?? [];
+ if (!willBeAdded({ requiredActionsToAdd, action })) {
+ return {
+ ...requiredActionsToAdd,
+ [action.pieceName]: [...actionNamesInPiece, action.actionName],
+ };
+ }
+ return {
+ ...requiredActionsToAdd,
+ [action.pieceName]: actionNamesInPiece.filter(
+ (actionName) => actionName !== action.actionName,
+ ),
+ };
+}
+
+function addRequiredSteps({
+ requiredActions,
+ piecesByName,
+ firstParentStepName,
+ addStep,
+}: {
+ requiredActions: MissingRequiredAction[];
+ piecesByName: Map<string, PieceMetadataModel>;
+ firstParentStepName: string;
+ addStep: BuilderState['handleAddingOrUpdatingStep'];
+}): string[] {
+ const addedStepNames: string[] = [];
+ for (const requiredAction of requiredActions) {
+ const piece = piecesByName.get(requiredAction.pieceName);
+ const action = piece?.actions[requiredAction.actionName];
+ if (!piece || !action) {
+ continue;
+ }
+ const stepName = addStep({
+ pieceSelectorItem: {
+ actionOrTrigger: action,
+ type: FlowActionType.PIECE,
+ pieceMetadata: stepUtils.mapPieceToMetadata({ piece, type: 'action' }),
+ },
+ operation: {
+ type: FlowOperationType.ADD_ACTION,
+ actionLocation: {
+ parentStep: addedStepNames.at(-1) ?? firstParentStepName,
+ stepLocationRelativeToParent: StepLocationRelativeToParent.AFTER,
+ },
+ },
+ selectStepAfter: addedStepNames.length === 0,
+ });
+ addedStepNames.push(stepName);
+ }
+ return addedStepNames;
+}
+
+export type FailedRequiredActionsCheck = {
+ result: RequiredActionsCheckResult;
+ piecesByName: Map<string, PieceMetadataModel>;
+};
+
+type MissingRequiredAction = {
+ pieceName: string;
+ actionName: string;
+ displayName: string;
+ skipped: boolean;
+};
+
+type MissingRequiredActionGroup = {
+ pieceName: string;
+ displayName: string;
+ logoUrl: string | undefined;
+ actions: MissingRequiredAction[];
+};
diff --git a/packages/web/src/app/components/project-settings/pieces/index.tsx b/packages/web/src/app/components/project-settings/pieces/index.tsx
index 2e28f8caf89..91e84d26a90 100644
--- a/packages/web/src/app/components/project-settings/pieces/index.tsx
+++ b/packages/web/src/app/components/project-settings/pieces/index.tsx
@@ -87,9 +87,7 @@ const PiecesSettings = () => {
isTableQuery: true,
});
- const { data: pieceSet } = pieceSetQueries.usePieceSet(
- project.pieceSetId ?? '',
- );
+ const { data: pieceSet } = pieceSetQueries.useProjectPieceSet(project.id);
const customFilters = useMemo(
() => [
diff --git a/packages/web/src/app/routes/mcp-server/pieces/pieces-panel.tsx b/packages/web/src/app/routes/mcp-server/pieces/pieces-panel.tsx
index 098b569d50c..b96f488a601 100644
--- a/packages/web/src/app/routes/mcp-server/pieces/pieces-panel.tsx
+++ b/packages/web/src/app/routes/mcp-server/pieces/pieces-panel.tsx
@@ -13,7 +13,6 @@ import { VirtualizedList } from '@/components/ui/virtualized-list';
import { RequestTrial } from '@/features/billing';
import { pieceSetQueries } from '@/features/piece-sets';
import { piecesHooks } from '@/features/pieces/hooks/pieces-hooks';
-import { projectCollectionUtils } from '@/features/projects';
import { useIsPlatformAdmin } from '@/hooks/authorization-hooks';
import { platformHooks } from '@/hooks/platform-hooks';
@@ -184,10 +183,7 @@ function RunActionDisabledAlert({
function PieceSetBanner({ projectId }: { projectId: string | null }) {
const { platform } = platformHooks.useCurrentPlatform();
const isPlatformAdmin = useIsPlatformAdmin();
- const { data: projects = [] } = projectCollectionUtils.useAll();
- const pieceSetId =
- projects.find((project) => project.id === projectId)?.pieceSetId ?? null;
- const { data: pieceSet } = pieceSetQueries.usePieceSet(pieceSetId ?? '');
+ const { data: pieceSet } = pieceSetQueries.useProjectPieceSet(projectId);
if (!platform.plan.managePiecesEnabled) {
return (
@@ -225,8 +221,8 @@ function PieceSetBanner({ projectId }: { projectId: string | null }) {
>
<Link
to={
- pieceSetId
- ? `/platform/pieces/piece-sets/${pieceSetId}`
+ pieceSet
+ ? `/platform/pieces/piece-sets/${pieceSet.id}`
: PIECE_SETS_LIST_ROUTE
}
>
diff --git a/packages/web/src/features/flows/hooks/flow-hooks.tsx b/packages/web/src/features/flows/hooks/flow-hooks.tsx
index 04fd72e32a4..a5ad4e86ace 100644
--- a/packages/web/src/features/flows/hooks/flow-hooks.tsx
+++ b/packages/web/src/features/flows/hooks/flow-hooks.tsx
@@ -2,6 +2,7 @@ import {
ApErrorParams,
isNil,
ErrorCode,
+ RequiredActionsMissingErrorParams,
SeekPage,
} from '@activepieces/core-utils';
import {
@@ -72,6 +73,7 @@ export const flowHooks = {
change,
onSuccess,
setIsPublishing,
+ onRequiredActionsMissing,
}: UseChangeFlowStatusParams) => {
const { data: enableFlowOnPublish } = flagsHooks.useFlag<boolean>(
ApFlagId.ENABLE_FLOW_ON_PUBLISH,
@@ -169,6 +171,15 @@ export const flowHooks = {
},
technicalDetailsDefaultOpen: isNil(reportedError),
});
+ } else if (apError.code === ErrorCode.REQUIRED_ACTIONS_MISSING) {
+ if (onRequiredActionsMissing) {
+ onRequiredActionsMissing(apError.params);
+ return;
+ }
+ toast.error(t('Publish failed'), {
+ description: apError.params.message,
+ duration: 5000,
+ });
} else if (apError.code === ErrorCode.QUOTA_EXCEEDED) {
toast.error(t('Active flows limit reached'), {
description: t(
@@ -595,4 +606,7 @@ type UseChangeFlowStatusParams = {
change: 'publish' | FlowStatus;
onSuccess: (flow: PopulatedFlow) => void;
setIsPublishing?: (isPublishing: boolean) => void;
+ onRequiredActionsMissing?: (
+ params: RequiredActionsMissingErrorParams['params'],
+ ) => void;
};