@evergis/react 4.0.166 → 4.0.168

package/dist/components/Dashboard/actions/components/TaskExecutionHost/index.d.ts

@@ -0,0 +1,2 @@
+import { FC } from 'react';
+export declare const TaskExecutionHost: FC;

package/dist/components/Dashboard/actions/conditions/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const BINARY_PRECEDENCE: Record<string, number>;
+export declare const UNARY_PRECEDENCE = 7;
+export declare const ISO_DATE_LENGTH = 10;
+export declare const CONDITION_TOKEN: RegExp;

package/dist/components/Dashboard/actions/conditions/evaluateActionCondition.d.ts

@@ -0,0 +1,6 @@
+import { ActionExecutionContext } from '../types';
+/**
+ * Ошибка выражения или отсутствующее значение делают ветку ложной. Произвольный JS не исполняется;
+ * значения фильтров и ответа задачи читаются общим механизмом подстановок как данные.
+ */
+export declare const evaluateActionCondition: (expression: string, context: ActionExecutionContext) => boolean;

package/dist/components/Dashboard/actions/conditions/operators.d.ts

@@ -0,0 +1,4 @@
+/** Читаем только собственные поля данных: прототипы и унаследованные свойства недоступны. */
+export declare const readActionProperty: (target: unknown, key: unknown) => unknown;
+/** По контракту Actions сравнения не преобразуют типы: ==/!= равнозначны ===/!==. */
+export declare const evaluateBinary: (operator: string, left: unknown, right: unknown) => unknown;

package/dist/components/Dashboard/actions/conditions/parseActionCondition.d.ts

@@ -0,0 +1,6 @@
+import { ConditionNode } from './types';
+/**
+ * Разбирает ограниченное выражение: приоритеты операторов, скобки, свойства, includes и Date.parse.
+ * Условия источников данных лишь форматируются для сервера; callback требует вычисления в браузере.
+ */
+export declare const parseActionCondition: (condition: string) => ConditionNode;

package/dist/components/Dashboard/actions/conditions/tokenizeActionCondition.d.ts

@@ -0,0 +1,2 @@
+import { ConditionToken } from './types';
+export declare const tokenizeActionCondition: (expression: string) => ConditionToken[];

package/dist/components/Dashboard/actions/conditions/types.d.ts

@@ -0,0 +1,43 @@
+import { ConfigToken } from '../../utils/configString/types';
+export type ConditionToken = {
+    kind: "literal";
+    text: string;
+    value: unknown;
+} | {
+    kind: "reference";
+    text: string;
+    reference: ConfigToken;
+} | {
+    kind: "operator";
+    text: string;
+};
+export type ConditionNode = {
+    kind: "literal";
+    value: unknown;
+} | {
+    kind: "reference";
+    token: ConfigToken;
+} | {
+    kind: "array";
+    items: ConditionNode[];
+} | {
+    kind: "unary";
+    operator: string;
+    operand: ConditionNode;
+} | {
+    kind: "binary";
+    operator: string;
+    left: ConditionNode;
+    right: ConditionNode;
+} | {
+    kind: "property";
+    target: ConditionNode;
+    key: ConditionNode;
+} | {
+    kind: "includes";
+    target: ConditionNode;
+    argument: ConditionNode;
+} | {
+    kind: "date";
+    argument: ConditionNode;
+};

package/dist/components/Dashboard/actions/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const ACTION_TYPES: readonly ["runTask", "setFilters", "openUrl", "openModal"];
+export declare const UNSAFE_ACTION_KEYS: Set<string>;
+export declare const ACTION_YIELD_INTERVAL = 50;
+export declare const ACTION_LONG_RUNNING_MS = 500;

package/dist/components/Dashboard/actions/context/ActionContextProvider.d.ts

@@ -0,0 +1,8 @@
+import { PropsWithChildren } from 'react';
+import { ActionExecutionContext } from '../types';
+import { WidgetType } from '../../types';
+export declare const ActionContextProvider: ({ type, value, children }: PropsWithChildren<{
+    type: WidgetType;
+    value: ActionExecutionContext;
+}>) => import("react/jsx-runtime").JSX.Element;
+export declare const useActionContext: (type: WidgetType) => ActionExecutionContext;

package/dist/components/Dashboard/actions/context/ActionNodeProvider.d.ts

@@ -0,0 +1,3 @@
+import { ActionNodeProps } from './bindingTypes';
+export declare const ActionNodeProvider: ({ children, path, recordId, event, attributes, disabled }: ActionNodeProps) => import("react/jsx-runtime").JSX.Element;
+export declare const useActionNode: () => import('./bindingTypes').ActionNodeValue;

package/dist/components/Dashboard/actions/context/ActionScopeProvider.d.ts

@@ -0,0 +1,5 @@
+import { ActionScopeProviderProps } from './bindingTypes';
+import { WidgetType } from '../../types';
+/** Вложенная модалка заменяет область своего виджета, сохраняя области соседних виджетов. */
+export declare const ActionScopeProvider: ({ type, scopes, signal, children }: ActionScopeProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const useActionScope: (type: WidgetType) => import('./bindingTypes').ActionScopeValue;

package/dist/components/Dashboard/actions/context/WidgetActionsProvider/hooks/useActionExecutors.d.ts

@@ -0,0 +1,3 @@
+import { createActionNavigation } from '../../../executors/createActionNavigation';
+import { SelectedFilters, WidgetType } from '../../../../types';
+export declare const useActionExecutors: (type: WidgetType, navigations: Map<string, ReturnType<typeof createActionNavigation>>, writeFilters: (filters: SelectedFilters) => void) => (action: import('../../..').ResolvedAction, context: import('../../..').ActionExecutionContext, control: import('../../../runtime/types').ActionExecutionControl) => unknown | Promise<unknown>;

package/dist/components/Dashboard/actions/context/WidgetActionsProvider/hooks/useActionFilters.d.ts

@@ -0,0 +1,6 @@
+import { SelectedFilters, WidgetType } from '../../../../types';
+/** Последовательные действия видят записанные фильтры даже при пакетном обновлении состояния React. */
+export declare const useActionFilters: (type: WidgetType, selected: SelectedFilters | undefined, getFilters?: () => SelectedFilters) => {
+    read: () => SelectedFilters;
+    write: (filters: SelectedFilters) => void;
+};

package/dist/components/Dashboard/actions/context/WidgetActionsProvider/index.d.ts

@@ -0,0 +1,2 @@
+import { WidgetActionsProviderProps } from './types';
+export declare const WidgetActionsProvider: ({ type, children, actionContextKey, actionsActive, getActionFilters, actionNavigation, }: WidgetActionsProviderProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/Dashboard/actions/context/WidgetActionsProvider/types.d.ts

@@ -0,0 +1,14 @@
+import { PropsWithChildren } from 'react';
+import { SelectedFilters, WidgetType } from '../../../types';
+export type WidgetActionsProviderProps = PropsWithChildren<{
+    type: WidgetType;
+    actionContextKey?: string;
+    actionsActive?: boolean;
+    actionNavigation?: ActionNavigationFactory;
+    getActionFilters?: () => SelectedFilters;
+}>;
+export interface ActionNavigation {
+    open: (url: string, target?: "_self" | "_blank") => void;
+    dispose: () => void;
+}
+export type ActionNavigationFactory = (reserve: boolean) => ActionNavigation;

package/dist/components/Dashboard/actions/context/bindingTypes.d.ts

@@ -0,0 +1,46 @@
+import { KeyboardEvent, MouseEvent, PropsWithChildren } from 'react';
+import { ActionEventData, ActionExecutionContext, ActionScopes, ConfigActionInvocation } from '../types';
+import { ClientFeatureAttribute, ConfigContainerChild, WidgetType } from '../../types';
+export interface ActionBindingOptions {
+    type?: WidgetType;
+    elementConfig?: ConfigContainerChild;
+    attributes?: ClientFeatureAttribute[];
+    eventData?: ActionEventData;
+    sourceKey?: string;
+    disabled?: boolean;
+}
+export interface WidgetActionsValue {
+    start: (actions: readonly ConfigActionInvocation[], scopes: ActionScopes, context: ActionExecutionContext, sourceKey: string, scopeSignal?: AbortSignal) => void;
+}
+export type ActionNodeProps = PropsWithChildren<{
+    path?: string;
+    recordId?: string | number;
+    event?: ActionEventData;
+    attributes?: ClientFeatureAttribute[];
+    disabled?: boolean;
+}>;
+export interface ActionNodeValue {
+    path: string;
+    recordId?: string | number;
+    event?: ActionEventData;
+    attributes?: ClientFeatureAttribute[];
+    disabled?: boolean;
+}
+export interface ActionBindingResult {
+    hasActions: boolean;
+    trigger: (data?: ActionEventData, attributes?: ClientFeatureAttribute[]) => void;
+    onClick?: (event: MouseEvent) => void;
+    onKeyDown?: (event: KeyboardEvent) => void;
+    role?: "button";
+    tabIndex?: number;
+}
+export interface ActionScopeValue {
+    scopes: ActionScopes;
+    key: string;
+    signal?: AbortSignal;
+}
+export type ActionScopeProviderProps = PropsWithChildren<{
+    type: WidgetType;
+    scopes: ActionScopes;
+    signal?: AbortSignal;
+}>;

package/dist/components/Dashboard/actions/executors/ActionNavigationError.d.ts

@@ -0,0 +1,4 @@
+export declare class ActionNavigationError extends Error {
+    readonly url: string;
+    constructor(url: string);
+}

package/dist/components/Dashboard/actions/executors/createActionNavigation.d.ts

@@ -0,0 +1,5 @@
+/** Один клик резервирует одну вкладку; неиспользованная вкладка закрывается при завершении цепочки. */
+export declare const createActionNavigation: (reserve: boolean) => {
+    open(url: string, target?: "_self" | "_blank"): void;
+    dispose(): void;
+};

package/dist/components/Dashboard/actions/executors/needsNavigationWindow.d.ts

@@ -0,0 +1,2 @@
+import { ActionScopes, ConfigActionInvocation } from '../types';
+export declare const needsNavigationWindow: (actions: readonly ConfigActionInvocation[], scopes: ActionScopes) => boolean;

package/dist/components/Dashboard/actions/hooks/useActionBindings.d.ts

@@ -0,0 +1,2 @@
+import { ActionBindingOptions, ActionBindingResult } from '../context/bindingTypes';
+export declare const useActionBindings: ({ type, elementConfig, attributes, eventData, sourceKey, disabled, }: ActionBindingOptions) => ActionBindingResult;

package/dist/components/Dashboard/actions/hooks/useChartActions.d.ts

@@ -0,0 +1,10 @@
+import { ConfigContainerChild, FilterItem, WidgetType } from '../../types';
+export declare const useChartActions: (type: WidgetType, chart: ConfigContainerChild, items: FilterItem[]) => {
+    clickable: boolean;
+    onItemClick: (item: FilterItem) => void;
+    filters: import('../../types').SelectedFilters;
+    formatFilterColor: (name: string, color: string, defaultColor?: string) => string;
+    hasAnyFilter: boolean;
+    isFiltered: (name: string) => boolean;
+    onFilter: (newValue: string) => void;
+};

package/dist/components/Dashboard/actions/index.d.ts

@@ -0,0 +1,20 @@
+export * from './types';
+export * from './registry/resolveActionInvocation';
+export * from './registry/mergeActionParameters';
+export * from './parameters/resolveActionParameters';
+export * from './conditions/evaluateActionCondition';
+export * from './conditions/parseActionCondition';
+export * from './runtime/types';
+export * from './runtime/createActionRuntime';
+export * from './runtime/executeActionSequence';
+export * from './validation/validateDashboardActions';
+export * from './context/ActionContextProvider';
+export * from './context/ActionNodeProvider';
+export * from './context/ActionScopeProvider';
+export * from './context/WidgetActionsProvider';
+export * from './context/WidgetActionsProvider/types';
+export * from '../../../contexts/WidgetActionsContext';
+export * from './context/bindingTypes';
+export * from './hooks/useActionBindings';
+export * from './modals/types';
+export * from './modals/hooks/useWidgetModals';

package/dist/components/Dashboard/actions/modals/WidgetModalHost/ModalWindow.d.ts

@@ -0,0 +1,2 @@
+import { ModalWindowProps } from './types';
+export declare const ModalWindow: ({ type, entry }: ModalWindowProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/Dashboard/actions/modals/WidgetModalHost/index.d.ts

@@ -0,0 +1,2 @@
+import { WidgetModalProps } from '../types';
+export declare const WidgetModalHost: ({ type }: WidgetModalProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/Dashboard/actions/modals/WidgetModalHost/types.d.ts

@@ -0,0 +1,6 @@
+import { WidgetModalEntry } from '../types';
+import { WidgetType } from '../../../types';
+export interface ModalWindowProps {
+    type: WidgetType;
+    entry: WidgetModalEntry;
+}

package/dist/components/Dashboard/actions/modals/WidgetModalsProvider/index.d.ts

@@ -0,0 +1,2 @@
+import { WidgetModalProps } from '../types';
+export declare const WidgetModalsProvider: ({ type, children }: WidgetModalProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/Dashboard/actions/modals/hooks/useAvailableModals.d.ts

@@ -0,0 +1,2 @@
+import { WidgetType } from '../../../types';
+export declare const useAvailableModals: (type: WidgetType) => any[];

package/dist/components/Dashboard/actions/modals/hooks/useModalAutoSync.d.ts

@@ -0,0 +1,2 @@
+import { ConfigDataSource, WidgetType } from '../../../types';
+export declare const useModalAutoSync: (type: WidgetType, sources: ConfigDataSource[]) => number;

package/dist/components/Dashboard/actions/modals/hooks/useModalSources.d.ts

@@ -0,0 +1,8 @@
+import { ConfigModal, WidgetType } from '../../../types';
+import { WidgetModalEntry } from '../types';
+export declare const useModalSources: (type: WidgetType, entry: WidgetModalEntry, modal?: ConfigModal) => {
+    type: WidgetType;
+    dataSources: import('../../../types').WidgetDataSource[];
+    configDataSources: import('../../../types').ConfigDataSource[];
+    isLoading: boolean;
+};

package/dist/components/Dashboard/actions/modals/hooks/useWidgetModals.d.ts

@@ -0,0 +1,2 @@
+import { WidgetType } from '../../../types';
+export declare const useWidgetModals: (type: WidgetType) => import('../types').WidgetModalManager;

package/dist/components/Dashboard/actions/modals/types.d.ts

@@ -0,0 +1,26 @@
+import { PropsWithChildren } from 'react';
+import { ActionExecutionContext, ActionScopes } from '../types';
+import { ConfigDataSource, WidgetDataSource, WidgetType } from '../../types';
+export interface WidgetModalSnapshot {
+    modalId: string;
+    revision: number;
+    context: ActionExecutionContext;
+}
+export interface WidgetModalEntry extends WidgetModalSnapshot {
+    scopes: ActionScopes;
+    signal: AbortSignal;
+}
+export type WidgetModalProps = PropsWithChildren<{
+    type: WidgetType;
+}>;
+export interface WidgetModalManager {
+    openedModals: readonly WidgetModalEntry[];
+    openModal: (modalId: string, context: ActionExecutionContext, scopes: ActionScopes, parameters?: Record<string, unknown>) => void;
+    closeModal: (modalId: string) => void;
+}
+export interface ModalDataOverlay {
+    type: WidgetType;
+    dataSources: WidgetDataSource[];
+    configDataSources: ConfigDataSource[];
+    isLoading: boolean;
+}

package/dist/components/Dashboard/actions/modals/utils/createModalStore.d.ts

@@ -0,0 +1,16 @@
+import { ActionExecutionContext, ActionScopes } from '../../types';
+import { WidgetModalEntry } from '../types';
+/** Сигналы выполнения не попадают в снимки состояния приложения или Redux. */
+export declare const createModalStore: () => {
+    getSnapshot: () => readonly WidgetModalEntry[];
+    subscribe: (listener: () => void) => () => void;
+    open: (modalId: string, context: ActionExecutionContext, scopes: ActionScopes) => {
+        modalId: string;
+        revision: number;
+        context: ActionExecutionContext;
+        scopes: ActionScopes;
+        signal: AbortSignal;
+    };
+    close: (modalId: string) => void;
+    clear: () => void;
+};

package/dist/components/Dashboard/actions/modals/utils/modalRequestKey.d.ts

@@ -0,0 +1,4 @@
+import { ConfigDataSource } from '../../../types';
+import { ConfigStringSources } from '../../../utils/configString/types';
+/** Ключ учитывает подставленные значения: посторонние изменения фильтров и карты не сбрасывают данные. */
+export declare const modalRequestKey: (sources: ConfigDataSource[], context: ConfigStringSources) => string;

package/dist/components/Dashboard/actions/parameters/resolveActionParameters.d.ts

@@ -0,0 +1,3 @@
+import { ActionExecutionContext } from '../types';
+/** Все вложенные параметры одного шага читаются из одного контекста цепочки. */
+export declare const resolveActionParameters: (value: unknown, context: ActionExecutionContext) => unknown;

package/dist/components/Dashboard/actions/registry/mergeActionParameters.d.ts

@@ -0,0 +1 @@
+export declare const mergeActionParameters: (base: unknown, override: unknown) => unknown;

package/dist/components/Dashboard/actions/registry/resolveActionInvocation.d.ts

@@ -0,0 +1,2 @@
+import { ActionScopes, ConfigActionInvocation, ResolvedAction } from '../types';
+export declare const resolveActionInvocation: (invocation: ConfigActionInvocation, scopes: ActionScopes) => ResolvedAction;

package/dist/components/Dashboard/actions/runtime/awaitActionStep.d.ts

@@ -0,0 +1,2 @@
+/** При отмене прекращаем ожидание операции, сохраняя обработку её возможной поздней ошибки. */
+export declare const awaitActionStep: (operation: Promise<unknown>, signal: AbortSignal) => Promise<unknown>;

package/dist/components/Dashboard/actions/runtime/createActionRuntime.d.ts

@@ -0,0 +1,3 @@
+import { ActionRuntime, ActionRuntimeOptions } from './types';
+/** Независимые цепочки по источникам клика; повторный клик заменяет только цепочку того же источника. */
+export declare const createActionRuntime: (options: ActionRuntimeOptions) => ActionRuntime;

package/dist/components/Dashboard/actions/runtime/executeActionSequence.d.ts

@@ -0,0 +1,3 @@
+import { ActionExecutionContext } from '../types';
+import { ActionExecutionControl, ActionRunRequest, ActionRuntimeOptions } from './types';
+export declare const executeActionSequence: (request: ActionRunRequest, options: ActionRuntimeOptions, control: ActionExecutionControl) => Promise<ActionExecutionContext>;

package/dist/components/Dashboard/actions/runtime/types.d.ts

@@ -0,0 +1,36 @@
+import { ConfigStringSources } from '../../utils/configString/types';
+import { ActionExecutionContext, ActionScopes, ConfigActionInvocation, ResolvedAction } from '../types';
+export type ActionCancelReason = "restart" | "user" | "lifecycle";
+export interface ActionExecutionControl {
+    signal: AbortSignal;
+    runId: string;
+    scopes: ActionScopes;
+    sourceKey: string;
+}
+export interface ActionRunResult {
+    status: "completed" | "cancelled" | "failed";
+    context: ActionExecutionContext;
+    error?: unknown;
+}
+export interface ActionRunHandle extends ActionExecutionControl {
+    sourceKey: string;
+    completion: Promise<ActionRunResult>;
+    cancel: (reason?: ActionCancelReason) => void;
+}
+export interface ActionRuntimeOptions {
+    execute: (action: ResolvedAction, context: ActionExecutionContext, control: ActionExecutionControl) => unknown | Promise<unknown>;
+    getSources?: (context: ActionExecutionContext) => ConfigStringSources;
+    onError?: (error: unknown, handle: ActionRunHandle) => void;
+    onLongRunning?: (handle: ActionRunHandle) => void;
+}
+export interface ActionRunRequest {
+    sourceKey: string;
+    actions: readonly ConfigActionInvocation[];
+    scopes: ActionScopes;
+    context: ActionExecutionContext;
+}
+export interface ActionRuntime {
+    start: (request: ActionRunRequest) => ActionRunHandle;
+    cancel: (sourceKey: string, reason?: ActionCancelReason) => void;
+    cancelAll: (reason?: ActionCancelReason) => void;
+}

package/dist/components/Dashboard/actions/types.d.ts

@@ -0,0 +1,81 @@
+import { ConfigStringSources } from '../utils/configString/types';
+import { SelectedFilters } from '../types';
+export type ActionEvent = "click";
+export type ActionParameters = Record<string, unknown>;
+export interface ActionOptionsMap {
+    runTask: {
+        taskName: string;
+        parameters?: ActionParameters;
+    };
+    setFilters: {
+        filters: SelectedFilters;
+    };
+    openUrl: {
+        url: string;
+        target?: "_self" | "_blank";
+    };
+    openModal: {
+        modalId: string;
+        parameters?: ActionParameters;
+    };
+}
+export type ActionType = keyof ActionOptionsMap;
+export type ConfigActionInline = {
+    [Kind in ActionType]: {
+        type: Kind;
+        id?: never;
+        options: ActionOptionsMap[Kind];
+        event?: ActionEvent;
+        callback?: ConfigActionCallback;
+    };
+}[ActionType];
+export type ConfigActionDefinition = {
+    [Kind in ActionType]: {
+        id: string;
+        type: Kind;
+        options: ActionOptionsMap[Kind];
+        event?: ActionEvent;
+        callback?: ConfigActionCallback;
+    };
+}[ActionType];
+export interface ConfigActionReference {
+    id: string;
+    type?: never;
+    event?: ActionEvent;
+    options?: ActionParameters;
+    callback?: ConfigActionCallback;
+}
+export type ConfigActionInvocation = ConfigActionInline | ConfigActionReference;
+export type ConfigActionCallback = ConfigActionInvocation | {
+    [condition: string]: ConfigActionInvocation;
+};
+export type ConfigActionScope = readonly ConfigActionDefinition[];
+export type ActionScopes = readonly ConfigActionScope[];
+export type ResolvedAction = {
+    [Kind in ActionType]: {
+        id?: string;
+        type: Kind;
+        options: ActionOptionsMap[Kind];
+        event: ActionEvent;
+        callback?: ConfigActionCallback;
+    };
+}[ActionType];
+export interface ActionEventData {
+    [key: string]: unknown;
+    nodeId?: string;
+    recordId?: string | number;
+    sourceKey?: string;
+}
+export interface ActionExecutionContext {
+    sources: ConfigStringSources;
+    event?: ActionEventData;
+    parameters?: ActionParameters;
+    taskResponse?: unknown;
+}
+export interface ActionValidationIssue {
+    path: string;
+    code: string;
+    message: string;
+    ownerId?: string;
+    severity: "error" | "warning";
+}

package/dist/components/Dashboard/actions/validation/actionShape.d.ts

@@ -0,0 +1,2 @@
+export declare const getActionShapeError: (action: Record<string, unknown>, definition: boolean) => string | undefined;
+export declare function getActionOptionsError(type: string, value: unknown): string | undefined;

package/dist/components/Dashboard/actions/validation/isActionSelectedFilter.d.ts

@@ -0,0 +1 @@
+export declare const isActionSelectedFilter: (filter: unknown) => boolean;

package/dist/components/Dashboard/actions/validation/types.d.ts

@@ -0,0 +1,15 @@
+import { ActionScopes, ActionValidationIssue } from '../types';
+export interface ValidationFrame {
+    node: Record<string, unknown>;
+    path: string;
+    scopes: ActionScopes;
+    tasks?: readonly unknown[];
+    definition: boolean;
+    declaration?: boolean;
+    ownerId?: string;
+}
+export interface ValidationState {
+    issues: ActionValidationIssue[];
+    modalIds: Set<string>;
+    actionIds: Set<string>;
+}

package/dist/components/Dashboard/actions/validation/validateActionTree.d.ts

@@ -0,0 +1,5 @@
+import { ActionValidationIssue, ConfigActionDefinition } from '../types';
+import { ValidationFrame, ValidationState } from './types';
+export declare const addActionIssue: (state: ValidationState, frame: ValidationFrame, message: string, code?: string, severity?: ActionValidationIssue["severity"]) => void;
+export declare const validateActionTree: (initial: ValidationFrame, state: ValidationState) => void;
+export declare const validateRegistry: (value: unknown, frame: ValidationFrame, state: ValidationState) => ConfigActionDefinition[];

package/dist/components/Dashboard/actions/validation/validateDashboardActions.d.ts

@@ -0,0 +1,3 @@
+import { ActionValidationIssue } from '../types';
+/** Проверка JSON использует общий механизм разрешения действий и разбора условий. Циклы допустимы. */
+export declare const validateDashboardActions: (config: unknown) => ActionValidationIssue[];