/// <reference types="react" />
import React$1, { ComponentType, ReactNode, ReactChild, ReactElement, CSSProperties, RefObject, InputHTMLAttributes, ChangeEvent } from 'react';
import { ColorResult } from 'react-color';
import { ReactDatePickerProps } from 'react-datepicker';
import { RouteProps } from 'react-router-dom';
import { StringMap } from 'quill';
import { Props, GroupBase } from 'react-select';
import { AsyncProps } from 'react-select/async';
import Skeleton from 'react-loading-skeleton';
import * as react_sortable_hoc from 'react-sortable-hoc';

interface IAddItemButtonProps {
    onClick: () => void;
    title?: string;
}
declare const AddItemButton: ({ onClick, title }: IAddItemButtonProps) => JSX.Element;

declare type TBoolFunc = () => boolean;
interface IEditorExtraProps<T> {
    showHistoryButtons?: boolean;
    showExportMenu?: boolean;
    exportIsAvailable?: boolean | TBoolFunc;
    postGetDataProcess?: (data: IPlugin<T>) => IPlugin<T> | Promise<IPlugin<T>>;
    extraMenuItems?: IExtraMenuItem[];
    extraToolbarButtons?: TChildren;
    preSaveValidation?: (data: IPlugin<T>) => Promise<IPreSaveValidation> | IPreSaveValidation;
}
interface IPreSaveValidation {
    valid: boolean;
    message?: string;
}
interface IExtraMenuItem {
    name: string;
    links: {
        children: TChildren;
        isPremium?: boolean;
    }[];
}
interface IEditorConfig<T> {
    sections: IEditorSection<T>[];
}
interface IEditorSection<T> {
    id: TActivePage;
    component: ComponentType;
    name: string;
    icon: any;
    badge?: string | number;
    context?: 'menu' | 'main';
}
declare type TActivePage = 'content' | 'styles' | 'settings' | 'analytics' | 'code' | 'view' | string;
interface IValidationError {
    message: string;
    context: string;
}
interface EditorHistory<T> {
    items: T[];
    activeIndex: number;
}
interface IEditorState<T> {
    isSaved: boolean;
    saving: boolean;
    hasError: boolean;
    history: EditorHistory<T>;
}
declare type TPlatform = 'website' | 'nindo' | 'duda' | 'wix' | 'weebly' | 'shopify' | 'bigcommerce' | 'woocommerce' | 'salesforce' | 'etsy' | 'square' | 'magento' | 'wordpress' | 'joomla' | 'drupal' | 'elementor' | 'webflow' | 'shift4shop' | 'squarespace';
declare type TSiteBuilderVendor = TPlatform;

declare type TChildren = ReactNode | ReactChild | ReactElement | JSX.Element[] | JSX.Element | string | Element[] | ComponentType;
declare type IPluginComp = () => ReactElement;
declare type IPluginLoaderComp = (props: {
    [x: string]: any;
}) => ReactElement;
declare type TPluginMode = 'preview' | 'editor' | 'viewer';
interface IPlugin<T> {
    type: string;
    data: T;
    galleryId: string | null;
    projectId?: string | null;
    guid: string | null;
    modelVersion: number;
    name: string;
    description: string | null;
    previewImage: string | null;
    creationSource: TPlatform;
    privacy: TPluginPrivacy;
    status: TPluginStatus;
    planFeatures: any;
}
declare type TPluginPrivacy = 'private' | 'public' | 'link';
declare type TPluginStatus = 'published' | 'draft';

interface IAssetsQueryParams {
    q: string;
    page: number;
    limit: number;
    total: number;
}
declare enum AssetType {
    IMAGE = "image",
    VIDEO = "video",
    AUDIO = "audio",
    PDF = "pdf",
    CSV = "csv",
    ALL = ""
}
interface IAsset {
    guid?: string;
    componentId?: string;
    userId: string;
    serviceName: string;
    assetType: AssetType;
    name: string;
    url: string;
    downloadUrl?: string;
}
interface IAssetFigure extends IAsset {
    thumbnail?: string;
    author?: {
        name: string;
        url: string;
    };
}
declare const FileTypes: Map<AssetType, string>;
interface IUnsplashImage {
    guid: string;
    thumbnail: string;
    url: string;
    downloadUrl: string;
    author: {
        name: string;
        url: string;
    };
    description: string;
}

interface AssetsGalleryOpenerProps {
    enabled: boolean;
    submitCallback: (url: string) => void;
    pluginId?: string;
    postUploadCallback?: (url: string, name: string, guid: string) => void;
    uploadStartCallback?: () => void;
    errorCallback?: (message: string) => void;
    disabledCallback?: () => void;
    assetApiBaseUrl?: string;
    limit?: number;
    children?: TChildren;
    className?: string;
    fileSizeLimitInMB?: number;
    assetType?: AssetType;
}
declare const AssetsGalleryOpener: (props: AssetsGalleryOpenerProps) => JSX.Element;

declare type ButtonProps = {
    children: TChildren;
    onClick?: (e?: any) => void;
    type?: 'button' | 'submit' | 'reset';
    className?: string;
    size?: 'small' | 'normal' | 'big';
    color?: 'gray' | 'green' | 'transparent';
    mode?: 'default' | 'major' | 'primary' | 'secondary';
    style?: CSSProperties;
    title?: string;
    icon?: string;
    disabled?: boolean;
    otherProps?: any;
};
declare const Button: (props: ButtonProps) => JSX.Element;

declare type IColorResult = ColorResult | null | string;

declare type TColorPickerPosition = 'top' | 'left' | 'bottom' | 'right';
interface ColorPickerProps {
    selectedColor: string;
    onChange: (color: IColorResult) => void;
    defaultColor?: string;
    colorFormat?: 'hex' | 'hsl' | 'rgb';
    showUndo?: boolean;
    disabled?: boolean;
    position?: TColorPickerPosition;
    enableTransparency?: boolean;
}
declare const ColorPicker: (props: ColorPickerProps) => JSX.Element;

interface IColorScheme {
    colors: string[];
    onChange: (colors: string[]) => void;
    colorFormat?: 'hex' | 'hsl' | 'rgb';
    max?: number;
}
declare const ColorScheme: ({ colors, colorFormat, onChange, max, }: IColorScheme) => JSX.Element;

interface ConfirmationPopupProps {
    title: string;
    message: string;
    show: boolean;
    approveButtonText?: string;
    closeCallback: () => void;
    approveCallback: () => void;
}
declare const ConfirmationPopup: (props: ConfirmationPopupProps) => JSX.Element;

interface IContextMenuSectionProps {
    children?: TChildren;
    title?: string;
    className?: string;
    titleElm?: any;
}
declare const ContextMenuSection: ({ title, titleElm, children, className, }: IContextMenuSectionProps) => JSX.Element;

interface IContextMenuWrapperProps {
    children: TChildren;
    className?: string;
}
declare const ContextMenuWrapper: ({ children, className, }: IContextMenuWrapperProps) => JSX.Element;

declare type CopyInputProps = {
    value: string;
    inputType?: 'input' | 'textarea';
    postMessageText?: string;
    className?: string;
    buttonClassName?: string;
    postMessageClassName?: string;
    postMessageTimeout?: number;
};
declare const CopyInput: (props: CopyInputProps) => JSX.Element;

interface ICSSPropertyGroup {
    name: TCSSPropertyGroupName;
    cssProperties?: TCSSProps[];
    displayName?: string;
    openedByDefault?: boolean;
}
declare type TAvailablePropertiesGroups = TCSSPropertyGroupName | (TCSSPropertyGroupName | ICSSPropertyGroup)[];
declare type TCSSPropertyGroupName = 'typography' | 'background' | 'borders' | 'spacing' | 'size';
declare type TCSSProps = 'fontSize' | 'fontFamily' | 'fontStyle' | 'lineHeight' | 'letterSpacing' | 'textAlign' | 'textDecorationLine' | 'textDecorationStyle' | 'textDecorationThickness' | 'textDecorationColor' | 'color' | 'fontWeight' | 'backgroundColor' | 'backgroundImage' | 'backgroundSize' | 'backgroundRepeat' | 'backgroundPosition' | 'borderRadius' | 'borderColor' | 'borderStyle' | 'borderWidth' | 'borderTopWidth' | 'borderRightWidth' | 'borderBottomWidth' | 'borderLeftWidth' | 'margin' | 'marginTop' | 'marginRight' | 'marginLeft' | 'marginBottom' | 'padding' | 'paddingTop' | 'paddingRight' | 'paddingBottom' | 'paddingLeft' | 'width' | 'height';

interface ICSSPropertiesEditorProps {
    currentProperties: CSSProperties;
    onChange: (nextProperties: CSSProperties) => void;
    availablePropertiesGroups?: TAvailablePropertiesGroups;
}
declare const CSSPropertiesEditor: (props: ICSSPropertiesEditorProps) => JSX.Element;

interface CustomCSSEditor<T> {
    onUpdate: (newStyles: string) => void;
    pluginComp: IPluginComp;
    css: string;
    title?: string;
    defaultStyles?: string;
}
declare const CustomCSSEditor: (props: CustomCSSEditor<any>) => JSX.Element;

declare const DatePicker: (props: ReactDatePickerProps) => JSX.Element;

declare const DescriptionFieldEditor: ({ richEditorMode, maxCharacters, imageUploadEnabled, }: {
    richEditorMode?: boolean | undefined;
    maxCharacters?: number | undefined;
    imageUploadEnabled?: boolean | undefined;
}) => JSX.Element;

interface IDisplayRulesTrigger {
    active: boolean;
    count: number;
}
interface IDisplayRulesTimeDelay extends IDisplayRulesTrigger {
    context: 'page' | 'website';
}
declare type TDisplayRulesPageCondition = 'contains' | 'not-contains' | 'starts-with' | 'ends-with' | 'not-equals' | 'equals';
interface IDisplayRulesPage {
    id: string;
    value: string;
    condition: TDisplayRulesPageCondition;
}
declare type TDisplayRulesDateRepeat = 'day' | 'week' | 'month' | 'year';
interface IDisplayRulesDate {
    id: string;
    from: string;
    to: string;
    fromHour: string;
    toHour: string;
    repeat: {
        active: boolean;
        count: number;
        period: TDisplayRulesDateRepeat;
        periodValues: number[];
    };
}

interface IDisplayRules {
    triggers: {
        timeDelay: IDisplayRulesTimeDelay;
        exitIntent: IDisplayRulesTrigger;
        pageScroll: IDisplayRulesTrigger;
        pageCount: IDisplayRulesTrigger;
        clickCount: IDisplayRulesTrigger;
        inactivity: IDisplayRulesTrigger;
        returningUser: IDisplayRulesTrigger;
        dates: {
            active: boolean;
            items: IDisplayRulesDate[];
        };
    };
    targeting: {
        device: {
            active: boolean;
            mobile: boolean;
            desktop: boolean;
        };
        page: {
            active: boolean;
            operator?: 'and' | 'or';
            rules: IDisplayRulesPage[];
        };
        frequency: {
            active: boolean;
            visitorType: 'all';
            frequencyType: 'day' | 'week' | 'month' | 'year' | 'session' | 'all';
            count: number;
        };
    };
}
declare const defaultDisplayRules: () => IDisplayRules;
declare const DisplayRulesSettings: ({ onChange, currentValue, }: {
    onChange: (displayRules: IDisplayRules) => void;
    currentValue?: IDisplayRules | undefined;
}) => JSX.Element;

interface IDrawerProps {
    className?: string;
    style?: CSSProperties;
    show: boolean;
    direction?: 'left' | 'right';
    showCloseButton?: boolean;
    closeCallback: () => void;
    children: TChildren;
    refCallback?: string | ((instance: HTMLDivElement | null) => void) | RefObject<HTMLDivElement> | null | undefined;
}
declare const Drawer: (props: IDrawerProps) => JSX.Element;

interface IExportElementButtonProps {
    exportSelector: string;
    exportUrl: string;
    exportFormat: 'image' | 'pdf';
    exportWidth?: number;
    exportHeight?: number;
    exportDelay?: number;
    exportHideElements?: string[];
    buttonTitle?: string;
    fileName?: string;
    automaticallyDownload?: boolean;
    exportStartCallback?: () => void;
    successCallback?: (url: string) => void;
    errorCallback?: (e: Error) => void;
}
declare const ExportElementButton: ({ exportUrl, automaticallyDownload, exportSelector, exportHideElements, exportFormat, fileName, buttonTitle, exportDelay, exportWidth, exportHeight, exportStartCallback, successCallback, errorCallback, }: IExportElementButtonProps) => JSX.Element;

interface IFileUploadProps {
    acceptType: AssetType;
    postUploadCallback: (url: string, name: string, guid: string, assetType: AssetType) => void;
    enabled: boolean;
    pluginId?: string;
    uploadStartCallback?: () => void;
    errorCallback?: (message: string) => void;
    disabledCallback?: () => void;
    uploadApiUrl?: string;
    sizeLimitInMB?: number;
    children?: TChildren;
    className?: string;
}
declare const FileUpload: (props: IFileUploadProps) => JSX.Element;

interface IFontFamilySelectorProps {
    selectedFontId: string;
    updateFont: (fontId: string) => void;
}
declare const FontFamilySelector: ({ selectedFontId, updateFont, }: IFontFamilySelectorProps) => JSX.Element;

declare type FormLabelProps = {
    isPremium?: boolean;
    otherProps?: any;
    children: TChildren;
};
declare const FormLabel: (props: FormLabelProps) => JSX.Element;

declare type FormRowProps = {
    children: TChildren;
    className?: string;
    flow?: 'column' | 'row';
    style?: CSSProperties;
};
declare const FormRow: (props: FormRowProps) => JSX.Element;

interface IInputProps extends InputHTMLAttributes<Element> {
    showInvalidMessage?: boolean;
}
declare const Input: ({ showInvalidMessage, ...props }: IInputProps) => JSX.Element;

interface IItemsManagerProps<T> {
    items: T[];
    itemRenderer: (item: T, idx: number) => TChildren;
    titleRenderer: (item: T, idx: number) => TChildren;
    newItemGenerator?: () => Partial<T>;
    onUpdate?: (updatedItems: T[]) => void;
    onItemToggle?: (item: T, isOpened: boolean, itemIdx: number) => void;
    onItemMouseEnter?: (item: T, itemIdx: number) => void;
    onItemMouseLeave?: (item: T, itemIdx: number) => void;
    maxItems?: number;
    minItems?: number;
    newItemPlacement?: 'first' | 'last';
    searchFilter?: (item: T, query: string) => boolean;
    searchable?: boolean;
    sortable?: boolean;
    addable?: boolean;
    removable?: boolean;
    extraActionsComp?: TChildren;
    addItemText?: string;
    itemsText?: string;
}
declare const ItemsManager: <T extends {
    id: string;
}>({ items, newItemGenerator, itemRenderer, titleRenderer, searchFilter, onUpdate, onItemToggle, onItemMouseEnter, onItemMouseLeave, maxItems, minItems, extraActionsComp, searchable, sortable, addable, removable, addItemText, itemsText, newItemPlacement, }: IItemsManagerProps<T>) => JSX.Element;

declare type LoaderProps = {
    children?: TChildren;
    size?: 'normal' | 'small' | 'big';
    className?: string;
    outerColor?: string;
    innerColor?: string;
};
declare const Loader: (props: LoaderProps) => JSX.Element;

declare const NameFieldEditor: () => JSX.Element;

interface IUser {
    isAuthenticated: boolean;
    fullName: string;
    thumbnail: string;
    isPremium?: boolean;
}

interface IUserStateMocks {
    userData?: IUser;
    planFeaturesData?: {
        [key: string]: any;
    };
}

interface IViewerProps<T> {
    postGetDataProcess?: (data: IPlugin<T>) => IPlugin<T> | Promise<IPlugin<T>>;
    onLoad?: (pluginData: IPlugin<T>) => void | Promise<void>;
    muteEvents?: boolean;
    dataRefreshTTL?: number;
    viewerSettings?: IViewerSettings;
}
interface IViewerSettings {
    inlineElm?: boolean;
    viewerSelector?: string;
    minHeight?: number;
    minWidth?: number;
    maxHeight?: number;
    maxWidth?: number;
    ignoreFrameResize?: boolean;
    onFrameResize?: (width: number, height: number) => void;
}

declare type TEditorConfigFunc<T> = (plugin: IPlugin<T>, pluginState: any) => Promise<IEditorConfig<T>> | IEditorConfig<T>;

interface IExtraRouteProps extends RouteProps {
    pageType?: 'viewer' | 'gallery' | 'editor';
}
declare type TEditorPropsGenerator<T> = (pluginData: IPlugin<T>) => IEditorExtraProps<T>;
declare type TPluginEditorProps<T> = IEditorExtraProps<T> | TEditorPropsGenerator<T>;
declare type TViewerPropsGenerator<T> = (pluginData: IPlugin<T>) => IViewerProps<T>;
declare type TPluginViewerProps<T> = IViewerProps<T> | TViewerPropsGenerator<T>;
interface IAppConfigMocks {
    disable?: boolean;
    userState?: Partial<IUserStateMocks>;
    origin?: string;
    customMocks?: any[];
}
interface IAppMeta {
    name?: string;
    icon?: string;
    url?: string;
    whiteLabeled?: boolean;
    type?: string;
    slug?: string;
    serviceName?: string;
}
interface IAppConfig<T, P = {}> {
    plugin: {
        defaultData: IPlugin<T>;
        pluginComponent: IPluginComp;
        loaderComponent?: IPluginLoaderComp;
        onMount?: (plugin: IPlugin<T>, firstLoad: boolean) => Promise<void> | void;
    };
    editor: {
        config: IEditorConfig<T> | TEditorConfigFunc<T>;
        loadTemplates?: boolean;
        props?: TPluginEditorProps<T>;
    };
    viewer?: {
        props?: TPluginViewerProps<T>;
    };
    app?: {
        extraRoutes?: IExtraRouteProps[];
        defaultRoutePath?: string;
        onInit?: () => void;
    };
    globalState?: P;
    meta?: IAppMeta;
    mocks?: IAppConfigMocks;
}

interface IAppPage {
    id: string;
    name?: string;
    component?: ReactElement;
    icon?: any;
}
interface IAppMainPage extends IAppPage {
    nestedRoutes?: IAppPage[];
}
interface IBackofficeAppConfig<T = {}, P = {}> {
    pages: IAppMainPage[];
    globalState?: P;
    loaderComponent?: ReactElement;
    onInit?: () => void;
    meta?: IAppMeta;
    mocks?: IAppConfigMocks;
}

declare function nindoApp<T, P = {}>(appConfig: IAppConfig<T, P>): void;
declare function nindoBackofficeApp<T, P = {}>(appConfig: IBackofficeAppConfig<T, P>): void;

interface INoCodeCSSItem {
    propName: string;
    value: CSSProperties;
    label?: string;
    allowedProps?: TAvailablePropertiesGroups;
}

declare const NoCodeCSSProps: ({ items, onChange }: {
    items: INoCodeCSSItem[];
    onChange: (propName: string, value: CSSProperties) => void;
}) => JSX.Element;

interface IHttpResult<T = any> {
    success: boolean;
    message?: string;
    data?: T;
}
interface ILocalState {
    state: 'init' | 'loading' | 'error' | 'success';
    message: string | null;
}
interface IPaginationQueryParams {
    q: string;
    page: number;
    limit: number;
    sortBy: string;
    desc: boolean;
}
interface IPaginationResponse<T = any> {
    docs: T[];
    total: number;
    limit: number;
    offset?: number;
    page: number;
    pages: number;
}

declare type PaginatedProps = {
    endpoint: string;
    itemsRenderer: (items: any[], page: number, pages: number, total: number) => ReactChild | ReactElement | JSX.Element[] | JSX.Element | string;
    loaderRenderer?: ReactChild | ReactElement | JSX.Element[] | JSX.Element | string;
    paginationRenderer?: (paginationState: IPaginationResponse, queryParams: IPaginationQueryParams, setQueryParams: (params: IPaginationQueryParams) => void) => ReactChild | ReactElement | JSX.Element[] | JSX.Element | string;
    errorRenderer?: (message: string) => ReactChild | ReactElement | JSX.Element[] | JSX.Element | string;
    emptyRenderer?: ReactChild | ReactElement | JSX.Element[] | JSX.Element | string;
    hooks?: {
        preFetch?: () => void;
        postFetch?: () => void;
    };
    paginationPosition?: 'top' | 'bottom' | 'both';
    wrapperClassName?: string;
    limit?: number;
    extraQueryParams?: string;
};
declare const Paginated: React$1.ForwardRefExoticComponent<PaginatedProps & React$1.RefAttributes<unknown>>;

interface PanelProps {
    titleComponent: TChildren;
    onToggle?: (isActive: boolean) => void;
    togglerComponent?: TChildren;
    children?: TChildren;
    collapsedGroups?: boolean;
    panelProps?: any;
    openedByDefault?: boolean;
    accordionMode?: boolean;
}
declare const Panel: (props: PanelProps) => JSX.Element;

declare const PluginSkeleton: ({ leadColor, }: {
    [key: string]: any;
    leadColor?: string | undefined;
}) => JSX.Element;

interface IPopupProps {
    className?: string;
    style?: any;
    show: boolean;
    closeCallback: any;
    children: TChildren;
    openInBackground?: boolean;
    refCallback?: string | ((instance: HTMLDivElement | null) => void) | RefObject<HTMLDivElement> | null | undefined;
}
declare const Popup: (props: IPopupProps) => JSX.Element;

declare type PremiumOpenerProps = {
    children: TChildren;
};
declare const PremiumOpener: (props: PremiumOpenerProps) => JSX.Element;

declare const PrivacySelector: () => JSX.Element;

interface IRibbonProps {
    iconUrl?: string;
    isLinkable?: boolean;
    text?: TChildren;
    link?: string;
}
declare const Ribbon: ({ isLinkable, link, iconUrl, text, }: IRibbonProps) => JSX.Element;

interface IRichEditorProps {
    html: string;
    onChange: (html: string) => void;
    onKeyDown?: (e: any) => void;
    formats?: string[];
    modules?: StringMap;
}
interface IRichEditorWithImageProps extends IRichEditorProps {
    imageUploadEnabled: boolean;
    assetApiBaseUrl?: string;
    pluginId?: string;
}
declare const RichEditor: (props: IRichEditorProps) => JSX.Element;
declare const RichEditorWithImages: (props: IRichEditorWithImageProps) => JSX.Element;

declare type NinjaSelectCommonProps = {
    mode: 'dark' | 'light';
};
declare type INinjaSelectProps = NinjaSelectCommonProps & Props;
declare type INinjaAsyncSelectProps = NinjaSelectCommonProps & AsyncProps<boolean, boolean, GroupBase<boolean>>;
declare const NinjaSelect: (props: INinjaSelectProps) => JSX.Element;
declare const NinjaAsyncSelect: (props: INinjaAsyncSelectProps) => JSX.Element;

interface IShadowHintProps {
    direction: 'top' | 'bottom' | 'left' | 'right';
    shadowStyle?: CSSProperties;
}
declare const ShadowHint: ({ direction, shadowStyle, }: IShadowHintProps) => JSX.Element;

declare type NinjaSkeletonThemeProps = {
    children: TChildren;
    leadColor?: string;
};
declare const NinjaSkeletonTheme: ({ leadColor, children, }: NinjaSkeletonThemeProps) => JSX.Element;
declare const NinjaSkeleton: typeof Skeleton;

interface ISkin<T> {
    name: string;
    skinStyles: T;
    color?: string | string[];
    thumbnail?: string | TChildren;
    isPremium?: boolean;
}

interface ISkinPickerProps<T> {
    skins: ISkin<T>[];
    onSelect: (skinStyles: T) => void;
    selectedIdx?: number;
    premiumSkinsAvailable?: boolean;
    skinItemStyle?: CSSProperties;
    skinItemBgStyle?: CSSProperties;
}
declare const SkinThumbnail: ({ color }: {
    color: string;
}) => JSX.Element;
declare const SkinPicker: <T>({ skins, onSelect, selectedIdx, premiumSkinsAvailable, skinItemStyle, skinItemBgStyle, }: ISkinPickerProps<T>) => JSX.Element;

interface SliderMark {
    [key: number]: ReactNode | string;
}
interface ISliderProps {
    min: number;
    max: number;
    step: number | null;
    value: number;
    theme: 'light' | 'dark';
    onChange: (num: number) => void;
    tooltipFormatter?: (num: number) => string;
    marks?: SliderMark;
    styles?: ISliderTheme;
    dots?: boolean;
    disabled?: boolean;
    disableTooltip?: boolean;
}
interface ISliderTheme {
    railStyle?: CSSProperties;
    dotStyle?: CSSProperties;
    activeDotStyle?: CSSProperties;
    trackStyle?: CSSProperties;
    handleStyle?: CSSProperties;
    markStyle?: CSSProperties;
    tooltipStyle?: CSSProperties;
}
declare const NinjaSlider: (props: ISliderProps) => JSX.Element;

declare const DragHandler: React$1.ComponentClass<unknown, any>;
declare const SortableItem: React$1.ComponentClass<{
    data: any;
    renderItem: (data: any, index: number) => ReactElement;
    sortIndex: number;
    index: number;
} & react_sortable_hoc.SortableElementProps, any>;
declare const SortableList: React$1.ComponentClass<{
    items: any[];
    renderItem: (data: any, index: number) => ReactElement;
} & react_sortable_hoc.SortableContainerProps, any>;

interface ITableCell {
    content: TChildren;
    className?: string;
}
interface ITableRow {
    cells: ITableCell[];
    className?: string;
}
interface ITableProps {
    headers: TChildren[];
    rows: ITableRow[];
}
declare const Table: (props: ITableProps) => JSX.Element;

interface ITabsProps {
    items: ITab[];
    resolveTabComp: (activeTabId: string | number) => TChildren;
}
interface ITab {
    id: string | number;
    name?: string;
}
declare const Tabs: ({ items, resolveTabComp }: ITabsProps) => JSX.Element;

declare type TSelectedType = string | number;
interface IToggleGroupProps {
    onChange: (selected: TSelectedType[]) => void;
    selectedOptions: TSelectedType[];
    options: {
        value: TSelectedType;
        label: string;
        disabled?: boolean;
        tooltip?: string;
    }[];
    allowMultiple: boolean;
    size?: number;
    disabled?: boolean;
    style?: CSSProperties;
    buttonStyle?: CSSProperties;
}
declare const ToggleGroup: (props: IToggleGroupProps) => JSX.Element;

interface ISwitchProps {
    isChecked: boolean;
    onChange: (event: ChangeEvent, isChecked: boolean) => void;
    name?: string;
    disabled?: boolean;
    width?: number;
    height?: number;
}
declare const Switch: (props: ISwitchProps) => JSX.Element;
declare const Toggler: (props: ISwitchProps) => JSX.Element;

interface IToolbarProps {
    saveCallback?: () => void;
    validation?: (data: IPlugin<any>) => Promise<IPreSaveValidation> | IPreSaveValidation;
    extraButtons?: TChildren;
    children?: ReactChild;
}
declare const Toolbar: (props: IToolbarProps) => JSX.Element;

declare const TooltipConfig: Partial<ITooltipProps>;
interface ITooltipProps {
    content: string;
    direction?: 'bottom' | 'left' | 'right' | 'top';
    pointer?: string;
    width?: number;
    backgroundColor?: string;
    textColor?: string;
    arrowColor?: string;
}
declare const Tooltip: (props: ITooltipProps) => JSX.Element;

interface ISettingsSectionProps {
    children: ReactNode;
    className?: string;
}
declare const SettingsSection: (props: ISettingsSectionProps) => JSX.Element;
interface ISettingsDetailsProps {
    title: string;
    description: string;
    className?: string;
}
declare const SettingsDetails: ({ title, description, className }: ISettingsDetailsProps) => JSX.Element;
interface ISettingsFormProps {
    children: ReactNode;
    className?: string;
}
declare const SettingsForm: ({ children, className }: ISettingsFormProps) => JSX.Element;

interface ICardProps {
    className?: string;
    children?: ReactNode;
    backgroundColor?: string;
    title?: string;
    titleSize?: number;
    textSize?: number;
    buttonTextSize?: number;
    titleColor?: string;
    textColor?: string;
    imgUrl?: string;
    topLineColor?: string;
    disableTopLine?: boolean;
    disableButton?: boolean;
    buttonColor?: string;
    buttonText?: string;
    onClick?: () => void;
    width?: number;
    widthUnit?: 'px' | '%' | 'rem';
}
declare const Card: (props: ICardProps) => JSX.Element;

interface IDataTableProps {
    className?: string;
    pageSize?: number;
    disableSearch?: boolean;
    disablePagination?: boolean;
    headers: string[];
    rows: Array<Array<any>>;
}
declare const DataTable: (props: IDataTableProps) => JSX.Element;

declare type TEventType = 'CLICK' | 'HOVER';
declare class EventHelper {
    pluginId: string;
    reportEngagementEvent(eventSubType: string, entityPath?: string, eventType?: TEventType): void;
    dispatchEventToFrame(frameId: string, action: any): void;
    updateViewerDimensions(height?: number, width?: number): void;
    updateViewerStyles(styles?: CSSProperties, elmToUpdate?: 'wrapper' | 'iframe' | 'both'): void;
    private openFrame;
    private updateFrameStyles;
    openFrameModal(frameId: string, frameUrl: string, backgroundMode?: boolean): void;
    toggleFrameModal(frameId: string, show: boolean): void;
    openFrameDrawer(frameId: string, frameUrl: string, backgroundMode?: boolean, direction?: 'left' | 'right'): void;
    toggleFrameDrawer(frameId: string, show: boolean, direction?: 'left' | 'right'): void;
}
declare const eventHelper: EventHelper;

declare type FontT = {
    id: string;
    name: string;
    family?: string;
    url?: string;
};
declare const fontsSizes: number[];
declare const fontsList: FontT[];
declare const oldFontMaping: Map<number, string>;
declare class FontHelper {
    getFontDetails(fontId: string): FontT;
}
declare const fontHelper: FontHelper;

interface IAppNotification {
    title?: string | JSX.Element | undefined;
    message?: string | JSX.Element | undefined;
    level?: "error" | "warning" | "info" | "success" | undefined;
    position?: "tr" | "tl" | "tc" | "br" | "bl" | "bc" | undefined;
    autoDismiss?: number | undefined;
    dismissible?: 'both' | 'button' | 'click' | 'hide' | 'none' | boolean | undefined;
    children?: React.ReactNode | undefined;
    uid?: number | string | undefined;
}

declare class NotificationHelper {
    success(config: IAppNotification): void;
    error(config: IAppNotification): void;
    warning(config: IAppNotification): void;
    info(config: IAppNotification): void;
    show(config: IAppNotification): void;
    hide(uid: string | number): void;
    removeAll(): void;
}
declare const notificationHelper: NotificationHelper;

interface IAppMenuLink {
    url: string;
    name: string;
    id?: string;
    badge?: string | number;
    icon?: any;
    exact?: boolean;
}

interface IAppContext {
    appType: 'widget' | 'backoffice';
    platform?: TPlatform;
    mode?: TPluginMode;
    instanceId?: string;
    appId?: string;
    isInFrame?: boolean;
    isFrameInViewport?: boolean;
    frameDistanceFromTop?: number;
}

interface IUserSubscription {
    plan: {
        name: string;
        id: string;
    };
}
interface ICycle {
    period: 'month' | 'year';
    billingCycle: number;
    discount: number;
    description: string;
    default: boolean;
}
interface IFeature {
    name: string;
    display: string;
    tip: null | string;
    highlight: boolean;
}
interface IFeatureGroup {
    name: string;
    display: string;
    features: IFeature[];
}
interface IPlanIDs {
    [key: string]: {
        commonninja: string;
        bluesnap: string | number;
        paypalApi: string;
    };
}
interface IPlan {
    name: string;
    className: string;
    pricing: number;
    features: {
        [key: string]: string | number;
    };
    planIds?: IPlanIDs;
}
interface IPricingModel {
    _id: string;
    services: string[];
    name: string;
    description: string;
    cycles: ICycle[];
    featureGroups: IFeatureGroup[];
    plans: IPlan[];
}

interface ISiteVisitorContextSession {
    firstVisit: number;
    lastVisit: number;
    visits: number;
    clicks: number;
}
interface ISiteVisitorContextWebsiteSession extends ISiteVisitorContextSession {
    pages: number;
}
interface ISiteVisitorContextWidget {
    views: number[];
}
interface ISiteVisitorContext {
    websiteSession: ISiteVisitorContextWebsiteSession;
    pageSession: {
        [key: string]: ISiteVisitorContextSession;
    };
    widgetSession: {
        [key: string]: ISiteVisitorContextWidget;
    };
    lastActivity: number;
    domain: string;
    currentPage: string;
    language: string;
    country: string;
    timezone: string;
    device: 'desktop' | 'mobile';
    scrollPercantage: number;
    hasExitIntent: boolean;
    version: number;
}

interface ICommonState<T, P = {}> {
    user: IUser;
    globalState: P;
    context: IAppContext;
    editor: IEditorState<T>;
}
interface IAppState<T, P = {}> extends ICommonState<T, P> {
    plugin: IPlugin<T>;
    siteVisitorContext: ISiteVisitorContext;
}

declare const getDefaultPlugin: <T>(data: T, name?: string | undefined, status?: TPluginStatus | undefined) => IPlugin<T>;

declare class PremiumHelper {
    planFeatures: any;
    getFeatureValue<T = boolean | number | null>(featureName: string, planFeatures?: any): T;
}
declare const premiumHelper: PremiumHelper;

declare class HttpService {
    queryParams: string;
    getPluginType(): string;
    getServiceName(): string;
    makeRequest(url: string, params?: any, isJson?: boolean): Promise<any>;
}

declare type THttpMethod = 'get' | 'post' | 'put' | 'delete';
interface IPaginationParams {
    limit?: number;
    page?: string | number;
    [key: string]: any;
}
interface IAPIProps {
    resourcePath: string;
    method?: THttpMethod;
    data?: any;
    dataType?: 'json' | 'form-data';
    pagination?: IPaginationParams;
    headers?: any;
}
declare class APIService extends HttpService {
    platform: TPlatform;
    constructor(platform?: TPlatform);
    request<T = any>({ resourcePath, method, data, dataType, pagination, headers, }: IAPIProps): Promise<IHttpResult<T>>;
    get<T = any>({ resourcePath, pagination, headers }: IAPIProps): Promise<IHttpResult<IPaginationResponse<T>>>;
    getOne<T = any>({ resourcePath, headers }: IAPIProps): Promise<IHttpResult<T>>;
    create<T = any>({ resourcePath, data, headers }: IAPIProps): Promise<IHttpResult<T>>;
    update<T = any>({ resourcePath, data, headers }: IAPIProps): Promise<IHttpResult<T>>;
    delete<T = any>({ resourcePath, headers }: IAPIProps): Promise<IHttpResult<T>>;
}

interface ILocalStorageObject {
    [key: string]: any;
}
declare class LocalStorageService {
    pluginId: string;
    private prefix;
    private isLocalStorageSupported;
    constructor();
    private getPluginStorage;
    private setPluginStorage;
    private deletePluginStorage;
    get(key: string): any;
    set(key: string, value: any): ILocalStorageObject;
    delete(key: string): ILocalStorageObject;
    destroyAll(): boolean;
}
declare const localStorageService: LocalStorageService;

interface IApiResourceState<T> {
    loading: boolean;
    error?: string;
    data?: T;
}
interface IApiResource<T> extends IApiResourceState<T> {
    fetchResource: () => Promise<void>;
}
declare function useApi<T = {}>({ resourcePath, method, data, pagination }: IAPIProps, platform?: TPlatform): IApiResource<T>;

declare function usePlugin<T>(): IPlugin<T>;

declare function useAppContext(): IAppContext;

declare function useAppData<T>(): [
    T,
    (updatedData: Partial<T>) => void
];

declare function useAppName(): [
    string,
    (newName: string) => void
];

declare function useAppStatus(): [
    TPluginStatus,
    (newStatus: TPluginStatus) => void
];

declare const useDisplayRules: (displayRules: IDisplayRules, debugMode?: boolean | undefined) => boolean;

declare function useGlobalState<P>(): [P, (updatedState: Partial<P>) => void];

declare function useQuery(): URLSearchParams;

declare function useSiteVisitorContext(): ISiteVisitorContext;

declare function useUserState(): IUser;

export { APIService, AddItemButton, AssetType, AssetsGalleryOpener, Button, CSSPropertiesEditor, Card, ColorPicker, ColorScheme, ConfirmationPopup, ContextMenuSection, ContextMenuWrapper, CopyInput, CustomCSSEditor, DataTable, DatePicker, DescriptionFieldEditor, DisplayRulesSettings, DragHandler, Drawer, EditorHistory, ExportElementButton, FileTypes, FileUpload, FontFamilySelector, FontT, FormLabel, FormRow, HttpService, IAPIProps, IAppConfig, IAppConfigMocks, IAppContext, IAppMenuLink, IAppMeta, IAppNotification, IAppState, IAsset, IAssetFigure, IAssetsQueryParams, IColorResult, ICycle, IDisplayRules, IEditorConfig, IEditorExtraProps, IEditorSection, IEditorState, IExtraMenuItem, IExtraRouteProps, IFeature, IFeatureGroup, IHttpResult, ILocalState, INoCodeCSSItem, IPaginationParams, IPaginationQueryParams, IPaginationResponse, IPlan, IPlanIDs, IPlugin, IPluginComp, IPluginLoaderComp, IPreSaveValidation, IPricingModel, ISiteVisitorContext, ISkin, IUnsplashImage, IUser, IUserStateMocks, IUserSubscription, IValidationError, IViewerProps, IViewerSettings, Input, ItemsManager, Loader, NameFieldEditor, NinjaAsyncSelect, NinjaSelect, NinjaSkeleton, NinjaSkeletonTheme, NinjaSlider, NoCodeCSSProps, Paginated, Panel, PluginSkeleton, Popup, PremiumOpener, PrivacySelector, Ribbon, RichEditor, RichEditorWithImages, SettingsDetails, SettingsForm, SettingsSection, ShadowHint, SkinPicker, SkinThumbnail, SortableItem, SortableList, Switch, TActivePage, TAvailablePropertiesGroups, TCSSPropertyGroupName, TCSSProps, TChildren, THttpMethod, TPlatform, TPluginEditorProps, TPluginMode, TPluginPrivacy, TPluginStatus, TPluginViewerProps, TSiteBuilderVendor, Table, Tabs, ToggleGroup, Toggler, Toolbar, Tooltip, TooltipConfig, defaultDisplayRules, eventHelper, fontHelper, fontsList, fontsSizes, getDefaultPlugin, localStorageService, nindoApp, nindoBackofficeApp, notificationHelper, oldFontMaping, premiumHelper, useApi, useAppContext, useAppData, useAppName, useAppStatus, useDisplayRules, useGlobalState, usePlugin, useQuery, useSiteVisitorContext, useUserState };