@antscorp/antsomi-ui 1.3.5-beta.31 → 1.3.5-beta.310

package/es/components/organism/ContentSources/Settings.js

@@ -0,0 +1,304 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+// Libraries
+import React, { memo, useEffect, useLayoutEffect, useState } from 'react';
+import { get, isArray, isEmpty, isNull, set } from 'lodash';
+// Locale
+import i18nInstance from '@antscorp/antsomi-ui/es/locales/i18n';
+import { translations } from '@antscorp/antsomi-ui/es/locales/translations';
+// Atoms
+import { Button } from '@antscorp/antsomi-ui/es/components/atoms';
+// Components
+import Content from './Content';
+// Styled
+import { ContentContainer } from './styled';
+// Constants
+import { ARTICLE_RANKING_DEFAULT, GET_TOP_RANKING_DEFAULT, MAX_NUM_OF_CONTENT_SOURCE, } from './constants';
+import { FILTERS_DEFAULT, ITEM_TYPE_NAME, PRODUCT_ITEM_TYPE_ID, PRODUCT_RANKING_DEFAULT, } from '@antscorp/antsomi-ui/es/constants/contentSource';
+// Queries
+import { useGetListBO } from '@antscorp/antsomi-ui/es/queries/BusinessObject';
+import { useGetListFallbackBO } from '@antscorp/antsomi-ui/es/queries/ThirdParty';
+import { getDataTableBOQuery } from '@antscorp/antsomi-ui/es/queries/BusinessObject/useGetDataTableBO';
+// Hooks
+import { useDeepCompareEffect } from '@antscorp/antsomi-ui/es/hooks';
+import { useDebounce } from '@antscorp/antsomi-ui/es/hooks/useDebounceV2';
+// Provider
+import { useContentSourceDispatch, useSelectBoIdByGroupFromCS, useSelectContentSources, useSelectModeView, } from './provider';
+import { deleteContentSourceGroup, setContentSourceGroup, setContentSourceGroupBOData, updateContentSourceSettings, updateModeView, emitItemTypeChange, } from './reducer';
+// Utils
+import { handleError } from '@antscorp/antsomi-ui/es/utils';
+const PATH = 'src/components/organism/ContentSources/Settings.tsx';
+const Settings = (props) => {
+    const { serviceAuth, mode, isShowErrorAlert, initValue, journeySettings, hideOptionTypes, onChange, onBOChange, } = props;
+    const { url = '', userId, token, accountId } = serviceAuth;
+    const { t } = i18nInstance;
+    const boIdByGroupCS = useSelectBoIdByGroupFromCS();
+    const contentSources = useSelectContentSources();
+    const { groups, expanded } = contentSources;
+    const modeView = useSelectModeView();
+    const isCDP = modeView === 'CDP';
+    const [isInitDataCDPDone, setIsInitDataCDPDone] = useState(false);
+    const [isLoadingDataTableBO, setIsLoadingDataTableBO] = useState(false);
+    const contentSourcesDebounce = useDebounce(contentSources, 400);
+    const { data: listBO, isLoading: isLoadingListBO, refetch: refetchListBO, } = useGetListBO({
+        url,
+    }, {
+        token,
+        userId,
+        accountId,
+    }, {
+        onSuccess(data) {
+            if (!isInitDataCDPDone &&
+                isCDP &&
+                isArray(data) &&
+                contentSources.groups.length === 1 &&
+                contentSources.groups[0] &&
+                !contentSources.groups[0].itemTypeId) {
+                const BOProduct = data.find(bo => +bo.id === PRODUCT_ITEM_TYPE_ID) || {};
+                const groupId = get(contentSources, 'groups[0].groupId', '');
+                const itemTypeId = BOProduct === null || BOProduct === void 0 ? void 0 : BOProduct.id;
+                const itemTypeDisplay = BOProduct === null || BOProduct === void 0 ? void 0 : BOProduct.label;
+                const itemTypeName = BOProduct === null || BOProduct === void 0 ? void 0 : BOProduct.name;
+                let valueRanking = GET_TOP_RANKING_DEFAULT;
+                if (itemTypeId === PRODUCT_ITEM_TYPE_ID) {
+                    valueRanking = PRODUCT_RANKING_DEFAULT;
+                    if (isCDP) {
+                        set(valueRanking, 'algorithms.sort', 'order');
+                    }
+                }
+                else if (itemTypeName === ITEM_TYPE_NAME.ARTICLE) {
+                    valueRanking = ARTICLE_RANKING_DEFAULT;
+                }
+                const newRanking = valueRanking;
+                if (groupId && itemTypeId) {
+                    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+                    contentSourceDispatch({
+                        type: 'SET_CONTENT_SOURCE_GROUP',
+                        payload: {
+                            groupId,
+                            values: {
+                                itemTypeId,
+                                itemTypeDisplay,
+                                itemTypeName,
+                                ranking: newRanking,
+                                filters: FILTERS_DEFAULT,
+                            },
+                        },
+                    });
+                    setIsInitDataCDPDone(true);
+                }
+            }
+        },
+    });
+    const { data: listFallbackBO } = useGetListFallbackBO({
+        serviceAuth,
+    });
+    const contentSourceDispatch = useContentSourceDispatch();
+    const handleChangeItemTypeId = ({ groupId, id, callback, }) => {
+        try {
+            const selected = listBO === null || listBO === void 0 ? void 0 : listBO.find((bo) => bo.value === id);
+            const itemTypeDisplay = selected === null || selected === void 0 ? void 0 : selected.label;
+            const itemTypeName = selected === null || selected === void 0 ? void 0 : selected.name;
+            let valueRanking = GET_TOP_RANKING_DEFAULT;
+            if (id === PRODUCT_ITEM_TYPE_ID) {
+                valueRanking = PRODUCT_RANKING_DEFAULT;
+                if (isCDP) {
+                    set(valueRanking, 'algorithms.sort', 'order');
+                }
+            }
+            else if (itemTypeName === ITEM_TYPE_NAME.ARTICLE) {
+                valueRanking = ARTICLE_RANKING_DEFAULT;
+            }
+            const newRanking = valueRanking;
+            if (groupId) {
+                contentSourceDispatch({
+                    type: 'SET_CONTENT_SOURCE_GROUP',
+                    payload: {
+                        groupId,
+                        values: {
+                            itemTypeId: id,
+                            itemTypeDisplay,
+                            itemTypeName,
+                            ranking: newRanking,
+                            filters: FILTERS_DEFAULT,
+                        },
+                    },
+                });
+                if (callback)
+                    callback();
+            }
+        }
+        catch (error) {
+            handleError(error, {
+                path: PATH,
+                name: 'handleChangeItemTypeId',
+                args: {},
+            });
+        }
+    };
+    const handleChangeContentSourceGroup = (groupId, action) => {
+        try {
+            switch (action.type) {
+                case 'BO_TYPE': {
+                    const { itemTypeId } = action.payload;
+                    if (itemTypeId) {
+                        handleChangeItemTypeId({ groupId, id: itemTypeId });
+                        contentSourceDispatch(emitItemTypeChange());
+                    }
+                    break;
+                }
+                case 'ALGORITHMS': {
+                    const { ranking } = action.payload;
+                    contentSourceDispatch(setContentSourceGroup({ groupId, values: { ranking } }));
+                    break;
+                }
+                case 'FILTER': {
+                    const { conditions } = action.payload;
+                    contentSourceDispatch(setContentSourceGroup({ groupId, values: { filters: conditions } }));
+                    break;
+                }
+                case 'FALLBACK': {
+                    const { fallback } = action.payload;
+                    if (fallback) {
+                        contentSourceDispatch(setContentSourceGroup({ groupId, values: { fallback } }));
+                    }
+                    break;
+                }
+                case 'NAME': {
+                    const { name } = action.payload;
+                    contentSourceDispatch(setContentSourceGroup({ groupId, values: { groupName: name } }));
+                    break;
+                }
+                case 'LEVEL': {
+                    const { level } = action.payload;
+                    contentSourceDispatch(setContentSourceGroup({ groupId, values: { level } }));
+                    break;
+                }
+                default: {
+                    throw new Error('Invalid action type');
+                }
+            }
+        }
+        catch (error) {
+            handleError(error, {
+                path: PATH,
+                name: 'handleChangeContentSourceGroup',
+                args: {
+                    groupId,
+                    action,
+                },
+            });
+        }
+    };
+    const handleDeleteContentSourceGroup = (groupId) => {
+        const group = contentSources.groups.find(g => g.groupId === groupId);
+        if (group)
+            // Re-use function in case change content source type
+            // for case remove content source
+            handleChangeItemTypeId({
+                groupId,
+                id: group.itemTypeId,
+                isDelete: true,
+                callback: () => contentSourceDispatch(deleteContentSourceGroup(groupId)),
+            });
+    };
+    useEffect(() => {
+        contentSourceDispatch({
+            type: 'SERVICE_AUTH',
+            payload: {
+                serviceAuth,
+            },
+        });
+    }, [serviceAuth, contentSourceDispatch]);
+    useLayoutEffect(() => {
+        if (mode) {
+            contentSourceDispatch(updateModeView(mode));
+        }
+    }, [mode, contentSourceDispatch]);
+    // INIT group in case using CDP mode
+    useLayoutEffect(() => {
+        if (isCDP && groups.length === 0) {
+            contentSourceDispatch({
+                type: 'ADD_CONTENT_SOURCE',
+                payload: {},
+            });
+        }
+    }, [isCDP, contentSourceDispatch, groups.length]);
+    // init data
+    useDeepCompareEffect(() => {
+        if (!isEmpty(initValue)) {
+            contentSourceDispatch(updateContentSourceSettings(initValue));
+            if (isCDP) {
+                setIsInitDataCDPDone(true);
+            }
+        }
+        else {
+            if (isCDP) {
+                refetchListBO();
+                setIsInitDataCDPDone(false);
+            }
+        }
+    }, [initValue, contentSourceDispatch, isCDP]);
+    useDeepCompareEffect(() => {
+        let ignore = false;
+        if (!isEmpty(boIdByGroupCS) && !isEmpty(serviceAuth)) {
+            const groupKeyList = Object.keys(boIdByGroupCS);
+            const fetchListCSDataTableBO = () => __awaiter(void 0, void 0, void 0, function* () {
+                const listPromises = [];
+                groupKeyList.forEach(groupId => {
+                    const itemTypeId = boIdByGroupCS[groupId];
+                    const promise = getDataTableBOQuery(serviceAuth, itemTypeId, { groupId });
+                    listPromises.push(promise);
+                });
+                setIsLoadingDataTableBO(true);
+                const listBOResponses = yield Promise.all(listPromises);
+                const boDataByGroupId = {};
+                listBOResponses.forEach(item => {
+                    const { data, params } = item;
+                    boDataByGroupId[params.groupId] = data.data;
+                });
+                if (!ignore) {
+                    contentSourceDispatch(setContentSourceGroupBOData(boDataByGroupId));
+                }
+                setIsLoadingDataTableBO(false);
+            });
+            fetchListCSDataTableBO();
+        }
+        return () => {
+            ignore = true;
+        };
+    }, [boIdByGroupCS, serviceAuth, contentSourceDispatch]);
+    // callback data out
+    useDeepCompareEffect(() => {
+        const groups = get(contentSourcesDebounce, 'groups', []);
+        const isValidCallbackOut = groups.every(group => !isNull(group.itemTypeId));
+        if (typeof onChange === 'function' && isValidCallbackOut) {
+            onChange(contentSourcesDebounce);
+        }
+    }, [contentSourcesDebounce]);
+    return (React.createElement(ContentContainer, { className: "contentsource-container" },
+        React.createElement(Content, { isLoadingListBO: isLoadingListBO || isLoadingDataTableBO, hideOptionTypes: hideOptionTypes, listBO: listBO, groups: groups, expanded: expanded, onChangeExpand: expanded => {
+                contentSourceDispatch({
+                    type: 'EXPANDED',
+                    payload: {
+                        expanded,
+                    },
+                });
+            }, onChangeGroup: (groupId, action) => {
+                handleChangeContentSourceGroup(groupId, action);
+            }, onDeleteGroup: groupId => handleDeleteContentSourceGroup(groupId), journeySettings: journeySettings, isShowErrorAlert: isShowErrorAlert, listFallbackBO: listFallbackBO || [] }),
+        groups.length < MAX_NUM_OF_CONTENT_SOURCE && !isCDP && (React.createElement(Button, { type: "text", onClick: () => contentSourceDispatch({
+                type: 'ADD_CONTENT_SOURCE',
+                payload: {},
+            }) },
+            "+ ",
+            t(translations.addGroup.title).toString()))));
+};
+export default memo(Settings);

package/es/components/organism/ContentSources/components/LevelSetting/constants.d.ts

@@ -0,0 +1,14 @@
+export declare const LEVEL_OPTIONS: {
+    parent: {
+        value: string;
+        label: string;
+    }[];
+    child: {
+        value: string;
+        label: string;
+    }[];
+    parent_child: {
+        value: string;
+        label: string;
+    }[];
+};

package/es/components/organism/ContentSources/components/LevelSetting/constants.js

@@ -0,0 +1,24 @@
+export const LEVEL_OPTIONS = {
+    parent: [
+        {
+            value: 'parent',
+            label: 'Parent',
+        },
+    ],
+    child: [
+        {
+            value: 'child',
+            label: 'Child',
+        },
+    ],
+    parent_child: [
+        {
+            value: 'parent',
+            label: 'Parent',
+        },
+        {
+            value: 'child',
+            label: 'Child',
+        },
+    ],
+};

package/es/components/organism/ContentSources/components/LevelSetting/index.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { RadioGroupContextProps } from 'antd/lib/radio';
+export interface ILevelSettingProps extends RadioGroupContextProps {
+    levelOption: string;
+}
+declare const _default: React.MemoExoticComponent<(props: ILevelSettingProps) => React.JSX.Element>;
+export default _default;

package/es/components/organism/ContentSources/components/LevelSetting/index.js

@@ -0,0 +1,23 @@
+// Libs
+import React from 'react';
+import i18nInstance from '@antscorp/antsomi-ui/es/locales/i18n';
+// Molecules
+import { RadioGroup, SettingWrapper } from '@antscorp/antsomi-ui/es/components/molecules';
+// Constants
+import { LEVEL_OPTIONS } from './constants';
+import { THEME } from '@antscorp/antsomi-ui/es/constants';
+import { LABEL_WIDTH } from '../../constants';
+// Locale
+import { translations } from '@antscorp/antsomi-ui/es/locales/translations';
+// Selectors
+import { useSelectModeView } from '../../provider';
+const LevelSetting = (props) => {
+    var _a;
+    const { t } = i18nInstance;
+    const { onChange, levelOption, value } = props;
+    const mode = useSelectModeView();
+    const isCDP = mode === 'CDP';
+    return (React.createElement(SettingWrapper, { label: t(translations.level.title).toString(), labelStyle: { fontWeight: mode === 'CDP' ? 'normal' : 'bold', width: LABEL_WIDTH }, labelColor: isCDP ? (_a = THEME.token) === null || _a === void 0 ? void 0 : _a.colorText : undefined, containerStyle: isCDP ? { justifyContent: 'flex-start' } : {} },
+        React.createElement(RadioGroup, { options: LEVEL_OPTIONS[levelOption], defaultValue: value, value: value, onChange: onChange })));
+};
+export default React.memo(LevelSetting);

package/es/components/organism/ContentSources/constants.d.ts

@@ -0,0 +1,7 @@
+import type { JourneySettings, TContentSourceSettings, TRanking } from './types';
+export declare const MAX_NUM_OF_CONTENT_SOURCE = 2;
+export declare const LABEL_WIDTH = 200;
+export declare const GET_TOP_RANKING_DEFAULT: TRanking;
+export declare const CONTENT_SOURCES_SETTINGS_DEFAULT: TContentSourceSettings;
+export declare const ARTICLE_RANKING_DEFAULT: TRanking;
+export declare const JOURNEY_SETTINGS_DEFAULT: JourneySettings;

package/es/components/organism/ContentSources/constants.js

@@ -0,0 +1,47 @@
+export const MAX_NUM_OF_CONTENT_SOURCE = 2;
+export const LABEL_WIDTH = 200;
+export const GET_TOP_RANKING_DEFAULT = {
+    type: 'algorithms',
+    algorithms: {
+        sort: 'mix',
+        value: [
+            {
+                value: 'get_top',
+                quantity: 5,
+                sort_type: 'desc',
+                sort_by: 'last_updated',
+            },
+        ],
+        filters: [],
+    },
+    custom: '',
+};
+export const CONTENT_SOURCES_SETTINGS_DEFAULT = {
+    groups: [],
+    expanded: [],
+    isLoadingDataBO: false,
+    emitItemTypeChange: 0,
+};
+export const ARTICLE_RANKING_DEFAULT = {
+    type: 'algorithms',
+    algorithms: {
+        sort: 'mix',
+        value: [
+            {
+                value: 'seen_products',
+                quantity: 5,
+            },
+        ],
+        filters: [],
+    },
+    custom: '',
+};
+export const JOURNEY_SETTINGS_DEFAULT = {
+    unsubscribeSegmentType: 'customer',
+    triggerType: 'event_based',
+    triggerEvent: {
+        eventActionId: '',
+        eventCategoryId: '',
+        insightPropertyIds: [],
+    },
+};

package/es/components/organism/ContentSources/index.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import { TServiceAuth } from '@antscorp/antsomi-ui/es/types';
+import { ContentSourceModeView, HideOptionTypes, JourneySettings, TContentSourceSettings } from './types';
+export interface ContentSourceProps {
+    useQueryClient: boolean;
+    serviceAuth: TServiceAuth;
+    isShowErrorAlert: boolean;
+    hideOptionTypes?: HideOptionTypes;
+    mode: ContentSourceModeView;
+    initValue?: TContentSourceSettings;
+    onChange: (contentSource: TContentSourceSettings) => void;
+    onBOChange?: (item: {
+        itemTypeId: number;
+    }) => void;
+    journeySettings: JourneySettings;
+}
+declare const _default: React.MemoExoticComponent<{
+    (props: ContentSourceProps): React.JSX.Element;
+    defaultProps: ContentSourceProps;
+}>;
+export default _default;

package/es/components/organism/ContentSources/index.js

@@ -0,0 +1,39 @@
+// Libraries
+import React, { memo } from 'react';
+// Query config
+import { queryClientAntsomiUI, QueryClientProviderAntsomiUI, } from '@antscorp/antsomi-ui/es/queries/configs';
+// Components
+import Settings from './Settings';
+// Providers
+import { ContentSourceProvider } from './provider';
+// Constants
+import { JOURNEY_SETTINGS_DEFAULT } from './constants';
+const defaultProps = {
+    useQueryClient: true,
+    isShowErrorAlert: false,
+    hideOptionTypes: {
+        filter: false,
+        level: false,
+        ranking: false,
+    },
+    journeySettings: JOURNEY_SETTINGS_DEFAULT,
+    mode: 'CDP',
+    onChange: () => { },
+    onBOChange: () => { },
+    serviceAuth: {
+        url: '',
+        token: '',
+        userId: '',
+        accountId: '',
+    },
+};
+const ContentSource = (props) => {
+    const { useQueryClient, serviceAuth, mode, isShowErrorAlert, initValue, hideOptionTypes, journeySettings, onChange, onBOChange, } = props;
+    if (!useQueryClient)
+        return (React.createElement(Settings, { mode: mode, initValue: initValue, hideOptionTypes: hideOptionTypes, serviceAuth: serviceAuth, isShowErrorAlert: isShowErrorAlert, journeySettings: journeySettings, onChange: onChange, onBOChange: onBOChange }));
+    return (React.createElement(QueryClientProviderAntsomiUI, { client: queryClientAntsomiUI },
+        React.createElement(ContentSourceProvider, null,
+            React.createElement(Settings, { mode: mode, initValue: initValue, hideOptionTypes: hideOptionTypes, serviceAuth: serviceAuth, isShowErrorAlert: isShowErrorAlert, journeySettings: journeySettings, onChange: onChange, onBOChange: onBOChange }))));
+};
+ContentSource.defaultProps = defaultProps;
+export default memo(ContentSource);

package/es/components/organism/ContentSources/provider.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { ContentSourceState } from './reducer';
+import type { UpdateGroupAction } from './types';
+export declare const ContentSourceContext: React.Context<ContentSourceState>;
+export declare const ContentSourceDispatchContext: React.Context<React.Dispatch<UpdateGroupAction>>;
+export interface ContentSourceProviderProps {
+    children: React.ReactNode;
+}
+export declare const ContentSourceProvider: ({ children }: ContentSourceProviderProps) => React.JSX.Element;
+export declare const useContentSourceState: () => ContentSourceState;
+export declare const useContentSourceDispatch: () => React.Dispatch<UpdateGroupAction>;
+export declare const useSelectServiceAuth: () => import("@antscorp/antsomi-ui/es/types").PayloadInfo;
+export declare const useSelectContentSources: () => import("./types").TContentSourceSettings;
+export declare const useSelectCSGroups: () => import("./types").TContentSourceGroup[];
+export declare const useSelectModeView: () => import("./types").ContentSourceModeView;
+export declare const useSelectEmitContentSourceItemType: () => number;
+export declare const useSelectBoIdByGroupFromCS: () => Record<string, number>;
+export declare const useSelectDataTableBOByGroupId: (groupId: string) => Record<string, any>[];

package/es/components/organism/ContentSources/provider.js

@@ -0,0 +1,60 @@
+// Libraries
+import React, { createContext, useContext, useMemo, useReducer } from 'react';
+import _ from 'lodash';
+// Reducer
+import { contentSourceReducer, initialContentSourceState } from './reducer';
+export const ContentSourceContext = createContext(initialContentSourceState);
+export const ContentSourceDispatchContext = createContext(() => { });
+export const ContentSourceProvider = ({ children }) => {
+    const [contentSourceState, dispatch] = useReducer(contentSourceReducer, initialContentSourceState);
+    return (React.createElement(ContentSourceContext.Provider, { value: contentSourceState },
+        React.createElement(ContentSourceDispatchContext.Provider, { value: dispatch }, children)));
+};
+// Hooks
+export const useContentSourceState = () => useContext(ContentSourceContext);
+export const useContentSourceDispatch = () => useContext(ContentSourceDispatchContext);
+// Selectors
+export const useSelectServiceAuth = () => {
+    const { serviceAuth } = useContentSourceState();
+    return useMemo(() => serviceAuth, [serviceAuth]);
+};
+export const useSelectContentSources = () => {
+    const { contentSources } = useContentSourceState();
+    return useMemo(() => contentSources, [contentSources]);
+};
+export const useSelectCSGroups = () => {
+    const { contentSources } = useContentSourceState();
+    return useMemo(() => contentSources.groups || [], [contentSources]);
+};
+export const useSelectModeView = () => {
+    const { mode } = useContentSourceState();
+    return useMemo(() => mode, [mode]);
+};
+export const useSelectEmitContentSourceItemType = () => {
+    const { emitItemTypeChange } = useSelectContentSources();
+    return useMemo(() => emitItemTypeChange, [emitItemTypeChange]);
+};
+export const useSelectBoIdByGroupFromCS = () => {
+    const csGroups = useSelectCSGroups();
+    const result = useMemo(() => {
+        const collectItemTypeId = {};
+        csGroups.forEach(group => {
+            if (group.itemTypeId !== null) {
+                collectItemTypeId[group.groupId] = group.itemTypeId;
+            }
+        });
+        return collectItemTypeId;
+    }, [csGroups]);
+    return result;
+};
+export const useSelectDataTableBOByGroupId = (groupId) => {
+    const csGroups = useSelectCSGroups();
+    const result = useMemo(() => {
+        const group = csGroups.find(group => group.groupId === groupId);
+        if (group) {
+            return _.get(group, 'data', []) || [];
+        }
+        return [];
+    }, [csGroups, groupId]);
+    return result;
+};

package/es/components/organism/ContentSources/reducer.d.ts

@@ -0,0 +1,19 @@
+import { UpdateGroupAction, TContentSourceSettings, TContentSourceGroup, ActionSetContentSourceGroup, ActionDeleteContentSourceGroup, ContentSourceModeView, ActionUpdateModeView, ActionUpdateContentSourceSettings, ActionSetContentSourceGroupBOData, ActionEmitItemTypeChange } from './types';
+import { TServiceAuth } from '@antscorp/antsomi-ui/es/types';
+export interface ContentSourceState {
+    serviceAuth: TServiceAuth;
+    mode: ContentSourceModeView;
+    contentSources: TContentSourceSettings;
+}
+export declare const initialContentSourceState: ContentSourceState;
+export declare const contentSourceReducer: (state: ContentSourceState, action: UpdateGroupAction) => ContentSourceState;
+export declare const setContentSourceGroup: (payload: {
+    groupId: string;
+    values: Partial<TContentSourceGroup>;
+    ignoreUndoAction?: boolean;
+}) => ActionSetContentSourceGroup;
+export declare const deleteContentSourceGroup: (groupId: string) => ActionDeleteContentSourceGroup;
+export declare const updateModeView: (mode: ContentSourceModeView) => ActionUpdateModeView;
+export declare const updateContentSourceSettings: (contentSources: TContentSourceSettings) => ActionUpdateContentSourceSettings;
+export declare const setContentSourceGroupBOData: (boDataByGroupId: Record<string, any[]>) => ActionSetContentSourceGroupBOData;
+export declare const emitItemTypeChange: () => ActionEmitItemTypeChange;