@elementor/editor-controls 3.33.0-99 → 3.34.2

package/dist/index.d.mts

@@ -1,8 +1,9 @@
 import * as React$1 from 'react';
-import { RefObject, ReactNode, FC, PropsWithChildren, ComponentType } from 'react';
-import { SxProps, UnstableColorFieldProps, ToggleButtonProps, StackProps, PopupState, FormLabelProps } from '@elementor/ui';
-import { StringPropValue, PropTypeUtil, PropValue, PropKey, SizePropValue, PropType, CreateOptions } from '@elementor/editor-props';
+import { RefObject, ReactNode, FC, PropsWithChildren, ReactElement, ComponentType } from 'react';
+import { SxProps, SelectProps, UnstableColorFieldProps, ToggleButtonProps, StackProps, PopupState, Theme, FormLabelProps, Grid } from '@elementor/ui';
+import { StringPropValue, PropTypeUtil, PropValue, PropKey, SizePropValue, LinkPropValue, TransformablePropValue, PropType, CreateOptions } from '@elementor/editor-props';
 import { StyleDefinitionState } from '@elementor/editor-styles';
+import { Editor } from '@tiptap/react';
 import * as _elementor_locations from '@elementor/locations';
 
 type ImageControlProps = {
@@ -14,19 +15,21 @@ type ImageControlProps = {
 };
 declare const ImageControl: ControlComponent<({ sizes, showMode }: ImageControlProps) => React$1.JSX.Element>;
 
-declare const TextControl: ControlComponent<({ placeholder, error, inputValue, inputDisabled, helperText, sx, }: {
+declare const TextControl: ControlComponent<({ placeholder, error, inputValue, inputDisabled, helperText, sx, ariaLabel, }: {
     placeholder?: string;
     error?: boolean;
     inputValue?: string;
     inputDisabled?: boolean;
     helperText?: string;
     sx?: SxProps;
+    ariaLabel?: string;
 }) => React$1.JSX.Element>;
 
-type Props$6 = {
+type Props$8 = {
     placeholder?: string;
+    ariaLabel?: string;
 };
-declare const TextAreaControl: ControlComponent<({ placeholder }: Props$6) => React$1.JSX.Element>;
+declare const TextAreaControl: ControlComponent<({ placeholder, ariaLabel }: Props$8) => React$1.JSX.Element>;
 
 declare const lengthUnits: readonly ["px", "%", "em", "rem", "vw", "vh"];
 declare const angleUnits: readonly ["deg", "rad", "grad", "turn"];
@@ -52,6 +55,8 @@ type BaseSizeControlProps = {
     min?: number;
     enablePropTypeUnits?: boolean;
     id?: string;
+    ariaLabel?: string;
+    isRepeaterControl?: boolean;
 };
 type LengthSizeControlProps = BaseSizeControlProps & UnitProps<LengthUnit[]> & {
     variant: 'length';
@@ -63,7 +68,7 @@ type TimeSizeControlProps = BaseSizeControlProps & UnitProps<TimeUnit[]> & {
     variant: 'time';
 };
 type SizeControlProps = LengthSizeControlProps | AngleSizeControlProps | TimeSizeControlProps;
-declare const SizeControl: ControlComponent<({ variant, defaultUnit, units, placeholder, startIcon, anchorRef, extendedOptions, disableCustom, min, enablePropTypeUnits, id, }: Omit<SizeControlProps, "variant"> & {
+declare const SizeControl: ControlComponent<({ variant, defaultUnit, units, placeholder, startIcon, anchorRef, extendedOptions, disableCustom, min, enablePropTypeUnits, id, ariaLabel, }: Omit<SizeControlProps, "variant"> & {
     variant?: SizeVariant;
 }) => React$1.JSX.Element>;
 
@@ -76,22 +81,33 @@ type FilterPropName = {
 };
 declare const FilterRepeaterControl: ControlComponent<({ filterPropName }: FilterPropName) => React$1.JSX.Element>;
 
-type SelectOption = {
+type SelectOption$1 = {
     label: string;
     value: StringPropValue['value'];
     disabled?: boolean;
 };
-type Props$5 = {
-    options: SelectOption[];
+type SelectControlProps = {
+    options: SelectOption$1[];
     onChange?: (newValue: string | null, previousValue: string | null | undefined) => void;
+    MenuProps?: SelectProps['MenuProps'];
+    ariaLabel?: string;
+};
+declare const SelectControl: ControlComponent<({ options, onChange, MenuProps, ariaLabel }: SelectControlProps) => React$1.JSX.Element>;
+
+declare const collectionMethods: {
+    readonly 'off-canvas': () => SelectOption$1[];
+};
+type SelectControlWrapperProps = Parameters<typeof SelectControl>[0] & {
+    collectionId?: keyof typeof collectionMethods;
 };
-declare const SelectControl: ControlComponent<({ options, onChange }: Props$5) => React$1.JSX.Element>;
+declare const SelectControlWrapper: ControlComponent<({ collectionId, options, ...props }: SelectControlWrapperProps) => React$1.JSX.Element>;
 
-type Props$4 = Partial<Omit<UnstableColorFieldProps, 'value' | 'onChange'>> & {
+type Props$7 = Partial<Omit<UnstableColorFieldProps, 'value' | 'onChange'>> & {
     propTypeUtil?: PropTypeUtil<string, string>;
     anchorEl?: HTMLElement | null;
+    id?: string;
 };
-declare const ColorControl: ControlComponent<({ propTypeUtil, anchorEl, slotProps, ...props }: Props$4) => React$1.JSX.Element>;
+declare const ColorControl: ControlComponent<({ propTypeUtil, anchorEl, slotProps, id, ...props }: Props$7) => React$1.JSX.Element>;
 
 type RenderContentProps = {
     size: ToggleButtonProps['size'];
@@ -104,7 +120,7 @@ type ToggleButtonGroupItem<TValue> = {
 };
 type ExclusiveValue<TValue> = TValue;
 type NonExclusiveValue<TValue> = TValue[];
-type Props$3<TValue> = {
+type Props$6<TValue> = {
     disabled?: boolean;
     justify?: StackProps['justifyContent'];
     size?: ToggleButtonProps['size'];
@@ -121,7 +137,10 @@ type Props$3<TValue> = {
     value: ExclusiveValue<TValue>;
     onChange: (value: ExclusiveValue<TValue>) => void;
 });
-declare const ControlToggleButtonGroup: <TValue>({ justify, size, value, onChange, items, maxItems, exclusive, fullWidth, disabled, placeholder, }: Props$3<TValue>) => React$1.JSX.Element;
+declare const ToggleButtonGroupUi: <TValue>(props: Props$6<TValue> & {
+    ref?: React$1.Ref<HTMLDivElement>;
+}) => React$1.ReactElement;
+declare const ControlToggleButtonGroup: <TValue>(props: Props$6<TValue>) => React$1.JSX.Element;
 
 type ToggleControlProps<T extends PropValue> = {
     options: Array<ToggleButtonGroupItem<T> & {
@@ -131,8 +150,9 @@ type ToggleControlProps<T extends PropValue> = {
     size?: ToggleButtonProps['size'];
     exclusive?: boolean;
     maxItems?: number;
+    convertOptions?: boolean;
 };
-declare const ToggleControl: ControlComponent<({ options, fullWidth, size, exclusive, maxItems, }: ToggleControlProps<StringPropValue["value"]>) => React$1.JSX.Element>;
+declare const ToggleControl: ControlComponent<({ options, fullWidth, size, exclusive, maxItems, convertOptions, }: ToggleControlProps<StringPropValue["value"]>) => React$1.JSX.Element>;
 
 declare const NumberControl: ControlComponent<({ placeholder: labelPlaceholder, max, min, step, shouldForceInt, startIcon, }: {
     placeholder?: string;
@@ -144,27 +164,28 @@ declare const NumberControl: ControlComponent<({ placeholder: labelPlaceholder,
 }) => React$1.JSX.Element>;
 
 type MultiSizePropValue = Record<PropKey, SizePropValue>;
-type Item = {
+type Item$1 = {
     icon: ReactNode;
     label: string;
     bind: PropKey;
 };
-type EqualUnequalItems = [Item, Item, Item, Item];
-type Props$2<TMultiPropType extends string, TPropValue extends MultiSizePropValue> = {
+type EqualUnequalItems = [Item$1, Item$1, Item$1, Item$1];
+type Props$5<TMultiPropType extends string, TPropValue extends MultiSizePropValue> = {
     label: string;
     icon: ReactNode;
     tooltipLabel: string;
     items: EqualUnequalItems;
     multiSizePropTypeUtil: PropTypeUtil<TMultiPropType, TPropValue>;
 };
-declare function EqualUnequalSizesControl<TMultiPropType extends string, TPropValue extends MultiSizePropValue>({ label, icon, tooltipLabel, items, multiSizePropTypeUtil, }: Props$2<TMultiPropType, TPropValue>): React$1.JSX.Element;
+declare function EqualUnequalSizesControl<TMultiPropType extends string, TPropValue extends MultiSizePropValue>({ label, icon, tooltipLabel, items, multiSizePropTypeUtil, }: Props$5<TMultiPropType, TPropValue>): React$1.JSX.Element;
 
-declare const LinkedDimensionsControl: ({ label, isSiteRtl, extendedOptions, min, }: {
+type Props$4 = {
     label: string;
     isSiteRtl?: boolean;
     extendedOptions?: ExtendedOption[];
     min?: number;
-}) => React$1.JSX.Element;
+};
+declare const LinkedDimensionsControl: ({ label, isSiteRtl, extendedOptions, min }: Props$4) => React$1.JSX.Element;
 
 type FontCategory = {
     label: string;
@@ -173,12 +194,14 @@ type FontCategory = {
 type FontFamilyControlProps = {
     fontFamilies: FontCategory[];
     sectionWidth: number;
+    ariaLabel?: string;
 };
-declare const FontFamilyControl: ControlComponent<({ fontFamilies, sectionWidth }: FontFamilyControlProps) => React$1.JSX.Element>;
+declare const FontFamilyControl: ControlComponent<({ fontFamilies, sectionWidth, ariaLabel }: FontFamilyControlProps) => React$1.JSX.Element>;
 
 type SelectableItem = {
     type: 'item' | 'category';
     value: string;
+    disabled?: boolean;
 };
 
 type Category = {
@@ -197,11 +220,14 @@ type ItemSelectorProps = {
     icon: React$1.ElementType<{
         fontSize: string;
     }>;
+    disabledItems?: string[];
+    id?: string;
 };
-declare const ItemSelector: ({ itemsList, selectedItem, onItemChange, onClose, sectionWidth, title, itemStyle, onDebounce, icon, }: ItemSelectorProps) => React$1.JSX.Element;
+declare const ItemSelector: ({ itemsList, selectedItem, onItemChange, onClose, sectionWidth, title, itemStyle, onDebounce, icon, disabledItems, id, }: ItemSelectorProps) => React$1.JSX.Element;
 
-declare const UrlControl: ControlComponent<({ placeholder }: {
+declare const UrlControl: ControlComponent<({ placeholder, ariaLabel }: {
     placeholder?: string;
+    ariaLabel?: string;
 }) => React$1.JSX.Element>;
 
 type ControlProps<TControlProps = unknown> = TControlProps & {
@@ -210,17 +236,44 @@ type ControlProps<TControlProps = unknown> = TControlProps & {
     };
 };
 
-type Props$1 = ControlProps<{
+type Props$3 = ControlProps<{
     queryOptions: {
-        requestParams: Record<string, unknown>;
-        endpoint: string;
+        params: Record<string, unknown>;
+        url: string;
     };
     allowCustomValues?: boolean;
     minInputLength?: number;
     placeholder?: string;
     label?: string;
+    ariaLabel?: string;
 }>;
-declare const LinkControl: ControlComponent<(props: Props$1) => React$1.JSX.Element>;
+type DestinationProp = LinkPropValue['value']['destination'];
+declare const LinkControl: ControlComponent<(props: Props$3) => React$1.JSX.Element>;
+
+type SelectOption = {
+    label: string;
+    value: StringPropValue['value'];
+    disabled?: boolean;
+};
+type Props$2 = {
+    options: SelectOption[];
+    onChange?: (newValue: string | null, previousValue: string | null | undefined) => void;
+    fallbackLabels?: Record<string, string>;
+};
+declare const HtmlTagControl: ControlComponent<({ options, onChange, fallbackLabels }: Props$2) => React$1.JSX.Element>;
+
+type Props$1 = {
+    queryOptions: {
+        params: Record<string, unknown>;
+        url: string;
+    };
+    allowCustomValues?: boolean;
+    minInputLength?: number;
+    placeholder?: string;
+    onSetValue?: (value: DestinationProp | null) => void;
+    ariaLabel?: string;
+};
+declare const QueryControl: ControlComponent<(props: Props$1) => React$1.JSX.Element>;
 
 declare const GapControl: ({ label }: {
     label: string;
@@ -244,11 +297,17 @@ type TooltipAddItemActionProps = {
     ariaLabel?: string;
 };
 
+type Item<T> = {
+    disabled?: boolean;
+} & T;
+type RepeatablePropValue = TransformablePropValue<PropKey, PropValue>;
+
 type ChildControlConfig = {
     component: React.ComponentType;
     props?: Record<string, unknown>;
     propTypeUtil: PropTypeUtil<string, any>;
     label?: string;
+    isItemDisabled?: (item: Item<RepeatablePropValue>) => boolean;
 };
 
 type RepeatableControlProps = {
@@ -271,6 +330,7 @@ type KeyValueControlProps = {
     regexKey?: string;
     regexValue?: string;
     validationErrorMessage?: string;
+    escapeHtml?: boolean;
     getHelperText?: (key: string, value: string) => {
         keyHelper?: string;
         valueHelper?: string;
@@ -282,7 +342,7 @@ declare const PositionControl: () => React$1.JSX.Element;
 
 declare const TransformRepeaterControl: ControlComponent<() => React$1.JSX.Element>;
 
-declare const TransformBaseControl: ({ popupState, anchorRef, }: {
+declare const TransformSettingsControl: ({ popupState, anchorRef, }: {
     popupState: PopupState;
     anchorRef: React$1.RefObject<HTMLDivElement | null>;
 }) => React$1.JSX.Element;
@@ -301,6 +361,7 @@ type TransitionProperty = {
     label: string;
     value: string;
     unavailable?: boolean;
+    isDisabled?: boolean;
 };
 type TransitionCategory = {
     label: string;
@@ -313,35 +374,45 @@ declare const transitionsItemsList: {
     items: string[];
 }[];
 
-declare const ControlFormLabel: (props: FormLabelProps) => React$1.JSX.Element;
+declare const DateTimeControl: ControlComponent<({ inputDisabled }: {
+    inputDisabled?: boolean;
+}) => React$1.JSX.Element>;
 
-type CssEditorProps = {
+declare const InlineEditingControl: ControlComponent<() => React$1.JSX.Element>;
+
+type InlineEditorProps = {
     value: string;
-    onChange: (value: string, isValid: boolean) => void;
+    setValue: (value: string) => void;
+    attributes?: Record<string, string>;
+    sx?: SxProps<Theme>;
+    showToolbar?: boolean;
 };
-declare const CssEditor: ({ value, onChange }: CssEditorProps) => React$1.JSX.Element;
+declare const InlineEditor: React$1.ForwardRefExoticComponent<InlineEditorProps & React$1.RefAttributes<HTMLDivElement>>;
 
-type AnyComponentType = ComponentType<any>;
-declare const brandSymbol: unique symbol;
-type ControlComponent<TComponent extends AnyComponentType = AnyComponentType> = TComponent & {
-    [brandSymbol]: true;
+type InlineEditorToolbarProps = {
+    editor: Editor;
 };
-declare function createControl<T extends AnyComponentType>(Control: T): ControlComponent<T>;
+declare const InlineEditorToolbar: ({ editor }: InlineEditorToolbarProps) => React$1.JSX.Element;
 
-type ControlActionsItems = Array<{
-    id: string;
-    MenuItem: React$1.ComponentType;
-}>;
-type ControlActionsContext = {
-    items: ControlActionsItems;
+declare const ControlFormLabel: (props: FormLabelProps) => React$1.JSX.Element;
+
+type ClearIconButtonProps = {
+    onClick?: () => void;
+    tooltipText: React$1.ReactNode;
+    disabled?: boolean;
+    size?: 'tiny' | 'small' | 'medium' | 'large';
 };
-type ControlActionsProviderProps = PropsWithChildren<ControlActionsContext>;
-declare const ControlActionsProvider: ({ children, items }: ControlActionsProviderProps) => React$1.JSX.Element;
-declare const useControlActions: () => ControlActionsContext;
+declare const ClearIconButton: ({ tooltipText, onClick, disabled, size }: ClearIconButtonProps) => React$1.JSX.Element;
 
-type SetValueMeta = {
+type Action = {
+    type: string;
+    payload?: object;
+};
+type SetValueMeta<TAction = Action> = {
     bind?: PropKey;
     validation?: (value: PropValue) => boolean;
+    action?: TAction;
+    withHistory?: boolean;
 };
 type SetValue<T> = (value: T, options?: CreateOptions, meta?: SetValueMeta) => void;
 type PropContext<T extends PropValue, P extends PropType> = {
@@ -378,48 +449,170 @@ type UseBoundProp<TValue extends PropValue> = {
     placeholder?: TValue;
     path: PropKey[];
     restoreValue: () => void;
+    resetValue: () => void;
     isDisabled?: (propType: PropType) => boolean | undefined;
     disabled?: boolean;
 };
-declare function useBoundProp<T extends PropValue = PropValue, P extends PropType = PropType>(): PropKeyContextValue<T, P>;
+type EnhancedPropKeyContextValue<T, P> = PropKeyContextValue<T, P> & {
+    resetValue: () => void;
+};
+declare function useBoundProp<T extends PropValue = PropValue, P extends PropType = PropType>(): EnhancedPropKeyContextValue<T, P>;
 declare function useBoundProp<TKey extends string, TValue extends PropValue>(propTypeUtil: PropTypeUtil<TKey, TValue>): UseBoundProp<TValue>;
 
-type ControlReplacement = {
-    component: ComponentType;
-    condition: ({ value }: ConditionArgs) => boolean;
-};
-type ConditionArgs = {
-    value: PropValue;
+type AnchorEl = HTMLElement | null;
+type RepeaterItem<T> = {
+    disabled?: boolean;
+} & T;
+type RepeaterItemContentProps<T> = {
+    anchorEl: AnchorEl;
+    bind: PropKey;
+    value: T;
+    index: number;
 };
-type Props = PropsWithChildren<{
-    replacements: ControlReplacement[];
+type RepeaterItemContent<T> = React$1.ComponentType<RepeaterItemContentProps<T>>;
+type ItemsActionPayload<T> = Array<{
+    index: number;
+    item: T;
 }>;
-declare const ControlReplacementsProvider: ({ replacements, children }: Props) => React$1.JSX.Element;
-declare const createControlReplacementsRegistry: () => {
-    registerControlReplacement: (replacement: ControlReplacement) => void;
-    getControlReplacements: () => ControlReplacement[];
+type AddItemMeta<T> = {
+    type: 'add';
+    payload: ItemsActionPayload<T>;
+};
+type RemoveItemMeta<T> = {
+    type: 'remove';
+    payload: ItemsActionPayload<T>;
+};
+type DuplicateItemMeta<T> = {
+    type: 'duplicate';
+    payload: ItemsActionPayload<T>;
+};
+type ReorderItemMeta = {
+    type: 'reorder';
+    payload: {
+        from: number;
+        to: number;
+    };
+};
+type ToggleDisableItemMeta = {
+    type: 'toggle-disable';
+};
+type SetRepeaterValuesMeta<T> = SetValueMeta<AddItemMeta<T>> | SetValueMeta<RemoveItemMeta<T>> | SetValueMeta<DuplicateItemMeta<T>> | SetValueMeta<ReorderItemMeta> | SetValueMeta<ToggleDisableItemMeta>;
+type BaseItemSettings<T> = {
+    initialValues: T;
+    Label: React$1.ComponentType<{
+        value: T;
+        index: number;
+    }>;
+    Icon: React$1.ComponentType<{
+        value: T;
+    }>;
+    Content: RepeaterItemContent<T>;
+    actions?: (value: T) => React$1.ReactNode;
+};
+type SortableItemSettings<T> = BaseItemSettings<T> & {
+    getId: ({ item, index }: {
+        item: T;
+        index: number;
+    }) => string;
+};
+type RepeaterProps<T> = {
+    label: string;
+    values?: T[];
+    openOnAdd?: boolean;
+    setValues: (newValue: T[], _: CreateOptions, meta?: SetRepeaterValuesMeta<T>) => void;
+    disabled?: boolean;
+    disableAddItemButton?: boolean;
+    addButtonInfotipContent?: React$1.ReactNode;
+    showDuplicate?: boolean;
+    showToggle?: boolean;
+    showRemove?: boolean;
+    openItem?: number;
+    isSortable: false;
+    itemSettings: BaseItemSettings<T>;
+} | {
+    label: string;
+    values?: T[];
+    openOnAdd?: boolean;
+    setValues: (newValue: T[], _: CreateOptions, meta?: SetRepeaterValuesMeta<T>) => void;
+    disabled?: boolean;
+    disableAddItemButton?: boolean;
+    addButtonInfotipContent?: React$1.ReactNode;
+    showDuplicate?: boolean;
+    showToggle?: boolean;
+    showRemove?: boolean;
+    openItem?: number;
+    isSortable?: true;
+    itemSettings: SortableItemSettings<T>;
 };
+declare const Repeater: <T>({ label, itemSettings, disabled, openOnAdd, values: items, setValues: setItems, showDuplicate, showToggle, showRemove, disableAddItemButton, addButtonInfotipContent, openItem: initialOpenItem, isSortable, }: RepeaterProps<RepeaterItem<T>>) => React$1.JSX.Element;
 
+declare function FloatingActionsBar({ actions, children }: PropsWithChildren<{
+    actions: ReactElement[];
+}>): React$1.JSX.Element;
 declare function useFloatingActionsBar(): {
     open: boolean;
     setOpen: React$1.Dispatch<React$1.SetStateAction<boolean>>;
 };
 
-type ControlAdornmentsItems = Array<{
+declare const PopoverGridContainer: React$1.ForwardRefExoticComponent<{
+    gap?: number;
+    alignItems?: React$1.ComponentProps<typeof Grid>["alignItems"];
+    flexWrap?: React$1.ComponentProps<typeof Grid>["flexWrap"];
+} & {
+    children?: React$1.ReactNode | undefined;
+} & React$1.RefAttributes<unknown>>;
+
+type AnyComponentType = ComponentType<any>;
+declare const brandSymbol: unique symbol;
+type ControlComponent<TComponent extends AnyComponentType = AnyComponentType> = TComponent & {
+    [brandSymbol]: true;
+};
+declare function createControl<T extends AnyComponentType>(Control: T): ControlComponent<T>;
+
+type ControlActionsItems = Array<{
     id: string;
-    Adornment: ComponentType<{
-        customContext?: {
-            path: string[];
-            propType: PropType;
-        };
-    }>;
+    MenuItem: React$1.ComponentType;
 }>;
+type ControlActionsContext = {
+    items: ControlActionsItems;
+};
+type ControlActionsProviderProps = PropsWithChildren<ControlActionsContext>;
+declare const ControlActionsProvider: ({ children, items }: ControlActionsProviderProps) => React$1.JSX.Element;
+declare const useControlActions: () => ControlActionsContext;
+
+type AdornmentComponent = ComponentType<{
+    customContext?: {
+        path: string[];
+        propType: PropType;
+    };
+}>;
+type ControlAdornmentsItem = {
+    id: string;
+    Adornment: AdornmentComponent;
+};
 type ControlAdornmentsContext = {
-    items?: ControlAdornmentsItems;
+    items?: ControlAdornmentsItem[];
 };
 type ControlAdornmentsProviderProps = PropsWithChildren<ControlAdornmentsContext>;
 declare const ControlAdornmentsProvider: ({ children, items }: ControlAdornmentsProviderProps) => React$1.JSX.Element;
 
+type ControlReplacement = {
+    component: ComponentType;
+    condition: ({ value }: ConditionArgs) => boolean;
+};
+type ConditionArgs = {
+    value: PropValue;
+    placeholder?: PropValue;
+};
+type Props = PropsWithChildren<{
+    replacements: ControlReplacement[];
+}>;
+declare const ControlReplacementsProvider: ({ replacements, children }: Props) => React$1.JSX.Element;
+declare const createControlReplacementsRegistry: () => {
+    registerControlReplacement: (replacement: ControlReplacement) => void;
+    getControlReplacements: () => ControlReplacement[];
+};
+
 declare function ControlAdornments({ customContext, }: {
     customContext?: {
         path: string[];
@@ -433,9 +626,6 @@ declare const injectIntoRepeaterItemIcon: (args: _elementor_locations.Replaceabl
 declare const injectIntoRepeaterItemLabel: (args: _elementor_locations.ReplaceableInjectArgs<{
     value: PropValue;
 }>) => void;
-declare const injectIntoRepeaterHeaderActions: (args: _elementor_locations.InjectArgs<{
-    value: PropValue;
-}>) => void;
 declare const injectIntoRepeaterItemActions: (args: _elementor_locations.InjectArgs<{
     index: number;
 }>) => void;
@@ -448,4 +638,4 @@ type UseInternalStateOptions<TValue> = {
 };
 declare const useSyncExternalState: <TValue>({ external, setExternal, persistWhen, fallback, }: UseInternalStateOptions<TValue>) => readonly [TValue, (setter: ((value: TValue) => TValue) | TValue, options?: CreateOptions, meta?: SetValueMeta) => void];
 
-export { type AngleUnit, AspectRatioControl, BackgroundControl, BoxShadowRepeaterControl, ColorControl, type ControlActionsItems, ControlActionsProvider, ControlAdornments, ControlAdornmentsProvider, type ControlComponent, ControlFormLabel, ControlReplacementsProvider, ControlToggleButtonGroup, CssEditor, type EqualUnequalItems, EqualUnequalSizesControl, type ExtendedOption, FilterRepeaterControl, type FontCategory, FontFamilyControl, GapControl, ImageControl, ItemSelector, KeyValueControl, type LengthUnit, LinkControl, LinkedDimensionsControl, NumberControl, PopoverContent, PositionControl, PropKeyProvider, PropProvider, type PropProviderProps, RepeatableControl, SelectControl, type SetValue, SizeControl, StrokeControl, SvgMediaControl, SwitchControl, TextAreaControl, TextControl, type TimeUnit, type ToggleButtonGroupItem, ToggleControl, type ToggleControlProps, TransformBaseControl, TransformRepeaterControl, TransitionRepeaterControl, type Unit, UrlControl, createControl, createControlReplacementsRegistry, enqueueFont, injectIntoRepeaterHeaderActions, injectIntoRepeaterItemActions, injectIntoRepeaterItemIcon, injectIntoRepeaterItemLabel, transitionProperties, transitionsItemsList, useBoundProp, useControlActions, useFloatingActionsBar, useSyncExternalState };
+export { type AdornmentComponent, type AngleUnit, AspectRatioControl, BackgroundControl, BoxShadowRepeaterControl, ClearIconButton, ColorControl, type ControlActionsItems, ControlActionsProvider, ControlAdornments, ControlAdornmentsProvider, type ControlComponent, ControlFormLabel, ControlReplacementsProvider, ControlToggleButtonGroup, DateTimeControl, type EqualUnequalItems, EqualUnequalSizesControl, type ExtendedOption, FilterRepeaterControl, FloatingActionsBar, type FontCategory, FontFamilyControl, GapControl, HtmlTagControl, ImageControl, InlineEditingControl, InlineEditor, InlineEditorToolbar, ItemSelector, type ItemsActionPayload, KeyValueControl, type LengthUnit, LinkControl, LinkedDimensionsControl, NumberControl, PopoverContent, PopoverGridContainer, PositionControl, PropKeyProvider, PropProvider, type PropProviderProps, QueryControl, RepeatableControl, Repeater, type RepeaterItem, SelectControl, SelectControlWrapper, type SetRepeaterValuesMeta, type SetValue, type SetValueMeta, SizeControl, StrokeControl, SvgMediaControl, SwitchControl, TextAreaControl, TextControl, type TimeUnit, type ToggleButtonGroupItem, ToggleButtonGroupUi, ToggleControl, type ToggleControlProps, TransformRepeaterControl, TransformSettingsControl, TransitionRepeaterControl, type Unit, UrlControl, createControl, createControlReplacementsRegistry, enqueueFont, injectIntoRepeaterItemActions, injectIntoRepeaterItemIcon, injectIntoRepeaterItemLabel, transitionProperties, transitionsItemsList, useBoundProp, useControlActions, useFloatingActionsBar, useSyncExternalState };