@antscorp/antsomi-ui 1.3.5-beta.7 → 1.3.5-beta.71

package/es/constants/index.d.ts

@@ -1,4 +1,8 @@
-export { THEME } from './theme';
 export * from './storybook';
 export * from './gradientSetting';
 export * from './richMenu';
+export * from './datetime';
+export * from './keyCode';
+export * from './templateListing';
+export * from './theme';
+export * from './variables';

package/es/constants/index.js

@@ -1,4 +1,8 @@
-export { THEME } from './theme';
 export * from './storybook';
 export * from './gradientSetting';
 export * from './richMenu';
+export * from './datetime';
+export * from './keyCode';
+export * from './templateListing';
+export * from './theme';
+export * from './variables';

package/es/constants/queries.d.ts

@@ -11,4 +11,8 @@ export declare const QUERY_KEYS: {
     GET_LIST_PROMOTION_POOL: string;
     GET_LIST_CUSTOM: string;
     GET_SAVE_CUSTOM_FUNCTION: string;
+    GET_TEMPLATE_CATEGORY_LIST: string;
+    GET_OBJECT_TEMPLATE_LIST: string;
+    GET_OBJECT_TEMPLATE_DETAIL: string;
+    GET_SAVE_AS_GALLERY_PERMISSION_EMAILS: string;
 };

package/es/constants/queries.js

@@ -18,4 +18,9 @@ export const QUERY_KEYS = {
     // Custom Function
     GET_LIST_CUSTOM: 'GET_LIST_CUSTOM',
     GET_SAVE_CUSTOM_FUNCTION: 'GET_SAVE_CUSTOM_FUNCTION',
+    // Template Listing
+    GET_TEMPLATE_CATEGORY_LIST: 'GET_TEMPLATE_CATEGORY_LIST',
+    GET_OBJECT_TEMPLATE_LIST: 'GET_OBJECT_TEMPLATE_LIST',
+    GET_OBJECT_TEMPLATE_DETAIL: 'GET_OBJECT_TEMPLATE_DETAIL',
+    GET_SAVE_AS_GALLERY_PERMISSION_EMAILS: 'GET_SAVE_AS_GALLERY_PERMISSION_EMAILS',
 };

package/es/constants/templateListing.d.ts

@@ -0,0 +1,50 @@
+export declare const PUBLIC_LEVEL: {
+    readonly RESTRICTED: 0;
+    readonly PUBLIC: 1;
+};
+export declare const TEMPLATE_STATUS: {
+    readonly ACTIVE: 1;
+    readonly REMOVED: 80;
+};
+export declare const LIMIT_LIST_PER_PAGE = 10;
+export declare const CATEGORY_SPLIT_KEY = "::";
+export declare const LAYOUT_TEMPLATE: {
+    POP_UP: {
+        id: number;
+        name: string;
+        label: string;
+    };
+    FLOATING_BAR: {
+        id: number;
+        name: string;
+        label: string;
+    };
+    FULL_SCREEN: {
+        id: number;
+        name: string;
+        label: string;
+    };
+    INLINE: {
+        id: number;
+        name: string;
+        label: string;
+    };
+    SLIDE_IN: {
+        id: number;
+        name: string;
+        label: string;
+    };
+    GAMIFIED: {
+        id: number;
+        name: string;
+        label: string;
+    };
+};
+export declare const TEMPLATE_CATEGORY_KEYS: {
+    readonly INDUSTRY: "industry";
+    readonly SEASONALITY: "seasonality";
+    readonly GOAL: "goal";
+    readonly OBJECTIVE: "objective";
+    readonly JOURNEY_TYPE: "journey_type";
+    readonly LIFECYCLE_STAGE: "lifecycle_stage";
+};

package/es/constants/templateListing.js

@@ -0,0 +1,52 @@
+export const PUBLIC_LEVEL = {
+    RESTRICTED: 0,
+    PUBLIC: 1,
+};
+export const TEMPLATE_STATUS = {
+    ACTIVE: 1,
+    REMOVED: 80,
+};
+export const LIMIT_LIST_PER_PAGE = 10;
+export const CATEGORY_SPLIT_KEY = '::';
+export const LAYOUT_TEMPLATE = {
+    POP_UP: {
+        id: 1,
+        name: 'pop_up',
+        label: 'Popup',
+    },
+    FLOATING_BAR: {
+        id: 2,
+        name: 'floating_bar',
+        label: 'Floating Bar',
+    },
+    FULL_SCREEN: {
+        id: 3,
+        name: 'full_screen',
+        label: 'Fullscreen',
+    },
+    INLINE: {
+        id: 4,
+        name: 'inline',
+        label: 'Inline',
+    },
+    SLIDE_IN: {
+        id: 5,
+        name: 'slide_in',
+        label: 'Slide-in',
+    },
+    GAMIFIED: {
+        id: 6,
+        name: 'gamified',
+        label: 'Gamified',
+    },
+};
+export const TEMPLATE_CATEGORY_KEYS = {
+    // DEVICE_TYPE: 'device_type',
+    // TEMPLATE_TYPE: 'template_type',
+    INDUSTRY: 'industry',
+    SEASONALITY: 'seasonality',
+    GOAL: 'goal',
+    OBJECTIVE: 'objective',
+    JOURNEY_TYPE: 'journey_type',
+    LIFECYCLE_STAGE: 'lifecycle_stage',
+};

package/es/constants/theme.js

@@ -149,7 +149,7 @@ THEME.components = {
     },
     Tabs: {
         colorPrimary: '#1F5FAC',
-        horizontalItemPadding: '10px 20px',
+        horizontalItemPadding: '17px 30px',
         horizontalItemGutter: 0,
         lineWidthBold: 3,
         titleFontSize: 14,

package/es/constants/variables.d.ts

@@ -0,0 +1,19 @@
+export declare const OBJECT_TYPES: {
+    readonly DASHBOARD: 1;
+    readonly JOURNEY_OVERVIEW: 2;
+    readonly SEGMENT: 3;
+    readonly BUSINESS_OBJECT: 4;
+    readonly VIEW: 5;
+    readonly DESTINATION: 6;
+    readonly EXPLORATION: 7;
+    readonly MEDIA_TEMPLATE: 8;
+    readonly EMAIL_TEMPLATE: 9;
+    readonly JOURNEY_TEMPLATE: 10;
+    readonly RICH_MENU_TEMPLATE: 11;
+};
+export declare const GET_LIST_TYPE: {
+    readonly OWNER: 1;
+    readonly SHARE_WITH_ME: 2;
+    readonly HAVE_ACCESS: 3;
+    readonly SELECTOR: 4;
+};

package/es/constants/variables.js

@@ -0,0 +1,19 @@
+export const OBJECT_TYPES = {
+    DASHBOARD: 1,
+    JOURNEY_OVERVIEW: 2,
+    SEGMENT: 3,
+    BUSINESS_OBJECT: 4,
+    VIEW: 5,
+    DESTINATION: 6,
+    EXPLORATION: 7,
+    MEDIA_TEMPLATE: 8,
+    EMAIL_TEMPLATE: 9,
+    JOURNEY_TEMPLATE: 10,
+    RICH_MENU_TEMPLATE: 11,
+};
+export const GET_LIST_TYPE = {
+    OWNER: 1,
+    SHARE_WITH_ME: 2,
+    HAVE_ACCESS: 3,
+    SELECTOR: 4,
+};

package/es/hooks/index.d.ts

@@ -1,3 +1,7 @@
 /// <reference types="react" />
 export declare function useDeepCompareEffect(callback: React.EffectCallback, dependencies: React.DependencyList | undefined): void;
 export { useDeepCompareMemo } from './useDeepCompareMemo';
+export * from './useIntersectionObserver';
+export * from './useEffectOnlyOnce';
+export * from './useForceUpdate';
+export * from './useListingItemResize';

package/es/hooks/index.js

@@ -20,3 +20,7 @@ export function useDeepCompareEffect(callback, dependencies) {
     useEffect(callback, dependencies === null || dependencies === void 0 ? void 0 : dependencies.map(useDeepCompareMemoize));
 }
 export { useDeepCompareMemo } from './useDeepCompareMemo';
+export * from './useIntersectionObserver';
+export * from './useEffectOnlyOnce';
+export * from './useForceUpdate';
+export * from './useListingItemResize';

package/es/hooks/useEffectOnlyOnce.d.ts

@@ -0,0 +1,2 @@
+import { DependencyList } from 'react';
+export declare const useEffectOnlyOnce: (fn: Function, dependencies: DependencyList) => void;

package/es/hooks/useEffectOnlyOnce.js

@@ -0,0 +1,12 @@
+// Libraries
+import { useEffect, useState } from 'react';
+export const useEffectOnlyOnce = (fn, dependencies) => {
+    const [didLoad, setDidLoad] = useState(false);
+    useEffect(() => {
+        if (!didLoad) {
+            fn();
+            setDidLoad(true);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [...dependencies]);
+};

package/es/hooks/useForceUpdate.d.ts

@@ -0,0 +1 @@
+export declare const useForceUpdate: () => () => void;

package/es/hooks/useForceUpdate.js

@@ -0,0 +1,5 @@
+import { useCallback, useState } from 'react';
+export const useForceUpdate = () => {
+    const [, updateState] = useState();
+    return useCallback(() => updateState({}), []);
+};

package/es/hooks/useIntersectionObserver.d.ts

@@ -0,0 +1,57 @@
+import type { RefObject } from 'react';
+type ObserverCallback = (isIntersecting: boolean, entry: IntersectionObserverEntry) => void;
+/**
+ * Represents the options for configuring the Intersection Observer.
+ * @interface IntersectionObserverOptions
+ * @property {number | number[]} [threshold=0] - A threshold indicating the percentage of the target's visibility needed to trigger the callback.
+ * @property {Element | Document | null} [root=null] - The element that is used as the viewport for checking visibility of the target.
+ * @property {string} [rootMargin='0%'] - A margin around the root.
+ * @property {boolean} [freezeOnceVisible=false] - If true, freezes the intersection state once the element becomes visible.
+ * @property {ObserverCallback} [onChange] - A callback function to be invoked when the intersection state changes.
+ * @property {boolean} [initialIsIntersecting=false] - The initial state of the intersection.
+ */
+interface IntersectionObserverOptions extends IntersectionObserverInit {
+    freezeOnceVisible?: boolean;
+    onChange?: ObserverCallback;
+    initialIsIntersecting?: boolean;
+}
+/** Supports both array and object destructing */
+type IntersectionResult = [
+    (node?: Element | null) => void,
+    boolean,
+    IntersectionObserverEntry | undefined
+] & {
+    ref: (node?: Element | null) => void;
+    isIntersecting: boolean;
+    entry?: IntersectionObserverEntry;
+};
+/**
+ * Custom hook for tracking the intersection of a DOM element with its containing element or the viewport.
+ * @param {IntersectionObserverOptions} options - The options for the Intersection Observer.
+ * @returns {IntersectionResult} The ref callback, a boolean indicating if the element is intersecting, and the intersection observer entry.
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-intersection-observer)
+ * @see [MDN Intersection Observer API](https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API)
+ * @example
+ * // Example 1
+ * const [ref, isIntersecting, entry] = useIntersectionObserver({ threshold: 0.5 });
+ *
+ * // Example 2
+ * const { ref, isIntersecting, entry } = useIntersectionObserver({ threshold: 0.5 });
+ */
+export declare function useIntersectionObserver(options: IntersectionObserverOptions): IntersectionResult;
+/**
+ * @deprecated Use the new signature with an unique option object instead.
+ * Custom hook for tracking the intersection of a DOM element with its containing element or the viewport.
+ * @param {RefObject<Element>} elementRef - The ref object for the DOM element to observe.
+ * @param {IntersectionObserverOptions} [options] - The options for the Intersection Observer (optional).
+ * @returns {IntersectionObserverEntry | undefined} The intersection observer entry representing the state of the intersection.
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-intersection-observer)
+ * @see [MDN Intersection Observer API](https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API)
+ * @example
+ * const targetRef = useRef<HTMLDivElement>(null);
+ * const options = { threshold: 0.5 };
+ * const entry = useIntersectionObserver(targetRef, options);
+ * // Access the intersection details from the entry variable.
+ */
+export declare function useIntersectionObserver(elementRef: RefObject<Element>, legacyOptions: IntersectionObserverOptions): IntersectionObserverEntry | undefined;
+export {};

package/es/hooks/useIntersectionObserver.js

@@ -0,0 +1,97 @@
+/* eslint-disable prefer-destructuring */
+// Libraries
+import { useEffect, useRef, useState } from 'react';
+/**
+ * Custom hook for tracking the intersection of a DOM element with its containing element or the viewport.
+ * @param {IntersectionObserverOptions | RefObject<Element>} optionsOrLegacyRef - The options for the Intersection Observer.
+ * @param {?IntersectionObserverOptions} [legacyOptions] - The options for the Intersection Observer (optional, legacy).
+ * @returns {NewIntersectionResult | IntersectionObserverEntry | undefined} The ref callback, a boolean indicating if the element is intersecting, and the intersection observer entry.
+ * @see [Documentation](https://usehooks-ts.com/react-hook/use-intersection-observer)
+ * @see [MDN Intersection Observer API](https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API)
+ * @example
+ * // Example 1
+ * const [ref, isIntersecting, entry] = useIntersectionObserver({ threshold: 0.5 });
+ *
+ * // Example 2
+ * const { ref, isIntersecting, entry } = useIntersectionObserver({ threshold: 0.5 });
+ */
+export function useIntersectionObserver(optionsOrLegacyRef, legacyOptions) {
+    var _a;
+    // TODO: Remove this mess when the old signature is removed.
+    const isLegacySignature = 'current' in optionsOrLegacyRef;
+    const options = isLegacySignature ? legacyOptions : optionsOrLegacyRef;
+    const { threshold = 0, root = null, rootMargin = '0%', freezeOnceVisible = false, initialIsIntersecting = false, } = options !== null && options !== void 0 ? options : {};
+    const [newRef, setNewRef] = useState(null);
+    const ref = isLegacySignature ? optionsOrLegacyRef.current : newRef;
+    const [state, setState] = useState(() => ({
+        isIntersecting: initialIsIntersecting,
+        entry: undefined,
+    }));
+    const callbackRef = useRef();
+    callbackRef.current = options === null || options === void 0 ? void 0 : options.onChange;
+    const frozen = ((_a = state.entry) === null || _a === void 0 ? void 0 : _a.isIntersecting) && freezeOnceVisible;
+    useEffect(() => {
+        // Ensure we have a ref to observe
+        if (!ref)
+            return;
+        // Ensure the browser supports the Intersection Observer API
+        if (!('IntersectionObserver' in window))
+            return;
+        // Skip if frozen
+        if (frozen)
+            return;
+        let unobserve;
+        const observer = new IntersectionObserver((entries) => {
+            const thresholds = Array.isArray(observer.thresholds)
+                ? observer.thresholds
+                : [observer.thresholds];
+            entries.forEach(entry => {
+                const isIntersecting = entry.isIntersecting &&
+                    thresholds.some(threshold => entry.intersectionRatio >= threshold);
+                setState({ isIntersecting, entry });
+                if (callbackRef.current) {
+                    callbackRef.current(isIntersecting, entry);
+                }
+                if (isIntersecting && freezeOnceVisible && unobserve) {
+                    unobserve();
+                    unobserve = undefined;
+                }
+            });
+        }, { threshold, root, rootMargin });
+        observer.observe(ref);
+        return () => {
+            observer.disconnect();
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [
+        ref,
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+        JSON.stringify(threshold),
+        root,
+        rootMargin,
+        frozen,
+        freezeOnceVisible,
+    ]);
+    // ensures that if the observed element changes, the intersection observer is reinitialized
+    const prevRef = useRef(null);
+    useEffect(() => {
+        var _a;
+        if (!ref &&
+            ((_a = state.entry) === null || _a === void 0 ? void 0 : _a.target) &&
+            !freezeOnceVisible &&
+            !frozen &&
+            prevRef.current !== state.entry.target) {
+            prevRef.current = state.entry.target;
+            setState({ isIntersecting: initialIsIntersecting, entry: undefined });
+        }
+    }, [ref, state.entry, freezeOnceVisible, frozen, initialIsIntersecting]);
+    if (isLegacySignature) {
+        return state.entry;
+    }
+    const result = [setNewRef, !!state.isIntersecting, state.entry];
+    // Support object destructuring, by adding the specific values.
+    result.ref = result[0];
+    result.isIntersecting = result[1];
+    result.entry = result[2];
+    return result;
+}

package/es/hooks/useListingItemResize.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+interface ComponentSizeProps {
+    initialWidth: number;
+    gap: number;
+}
+export declare const useListingItemResize: (props: ComponentSizeProps) => {
+    ref: import("react").MutableRefObject<any>;
+    itemPerRow: number | undefined;
+    ratio: number;
+    gap: number;
+};
+export {};

package/es/hooks/useListingItemResize.js

@@ -0,0 +1,58 @@
+// Libraries
+import { useMemo, useRef } from 'react';
+import { useForceUpdate } from '@antscorp/antsomi-ui/es/hooks';
+import { isNumber } from 'lodash';
+const DEFAULT_RATIO = 1;
+export const useListingItemResize = (props) => {
+    var _a;
+    const { initialWidth, gap } = props;
+    // Ref
+    const ref = useRef(null);
+    const timeoutAfterChange = useRef(null);
+    // Hooks
+    const forceUpdate = useForceUpdate();
+    /* Variables */
+    const containerWidth = (_a = ref === null || ref === void 0 ? void 0 : ref.current) === null || _a === void 0 ? void 0 : _a.offsetWidth;
+    /* Memo */
+    /**
+     * The number of items per row to display in the container
+     */
+    const itemPerRow = useMemo(() => {
+        if (isNumber(containerWidth)) {
+            /**
+             * The temporary number of items per row that the container is able to contain
+             */
+            const tempItemPerRow = Math.floor(containerWidth / initialWidth);
+            const totalGapWidth = gap * (tempItemPerRow - 1);
+            /**
+             * Check if the container is able to contain the total items with @initialWidth including the total @gap size
+             */
+            const isPossibleContain = containerWidth >= tempItemPerRow * initialWidth + totalGapWidth;
+            /**
+             * If it doesn't, reduce the @itemPerRow by 1
+             */
+            return isPossibleContain ? tempItemPerRow : tempItemPerRow - 1;
+        }
+    }, [containerWidth, gap, initialWidth]);
+    /**
+     * The ratio of the new width and height to the initial length and height
+     */
+    const ratio = useMemo(() => {
+        if (isNumber(containerWidth) && isNumber(itemPerRow)) {
+            const totalGapWidth = gap * (itemPerRow - 1);
+            const newWidth = (containerWidth - totalGapWidth) / itemPerRow;
+            return newWidth / initialWidth;
+        }
+        return DEFAULT_RATIO;
+    }, [containerWidth, gap, initialWidth, itemPerRow]);
+    /* Events */
+    window.addEventListener('resize', () => {
+        if (timeoutAfterChange) {
+            clearTimeout(timeoutAfterChange.current);
+        }
+        timeoutAfterChange.current = setTimeout(() => {
+            forceUpdate();
+        }, 500);
+    });
+    return { ref, itemPerRow, ratio, gap };
+};

package/es/hooks/useScrollToEnd.d.ts

@@ -0,0 +1 @@
+export declare const useScrollToEnd: (containerRef: React.RefObject<HTMLDivElement>, callback: () => void) => boolean;

package/es/hooks/useScrollToEnd.js

@@ -0,0 +1,30 @@
+import { useState, useEffect, useCallback } from 'react';
+export const useScrollToEnd = (containerRef, callback) => {
+    const [isAtEnd, setIsAtEnd] = useState(false);
+    const handleScroll = useCallback(() => {
+        const container = containerRef.current;
+        if (!container) {
+            return;
+        }
+        const { clientHeight, scrollHeight, scrollTop } = container;
+        console.log({ clientHeight, scrollHeight, scrollTop });
+        const isScrolledToEnd = scrollTop + clientHeight >= scrollHeight;
+        setIsAtEnd(isScrolledToEnd);
+    }, [containerRef]);
+    useEffect(() => {
+        const container = containerRef.current;
+        if (!container) {
+            return;
+        }
+        container.addEventListener('scroll', handleScroll);
+        return () => {
+            container.removeEventListener('scroll', handleScroll);
+        };
+    }, [containerRef, handleScroll]);
+    useEffect(() => {
+        if (isAtEnd) {
+            callback();
+        }
+    }, [isAtEnd, callback]);
+    return isAtEnd;
+};

package/es/index.d.ts

@@ -1 +1,4 @@
 export * from './components';
+export * from './types';
+export * from './queries';
+export { snakeCaseToCamelCase, camelCaseToSnakeCase, getCategoriesFromObjectTemplate, } from './utils';

package/es/index.js

@@ -1 +1,4 @@
 export * from './components';
+export * from './types';
+export * from './queries';
+export { snakeCaseToCamelCase, camelCaseToSnakeCase, getCategoriesFromObjectTemplate, } from './utils';

package/es/locales/en/translation.json

@@ -228,5 +228,13 @@
         "ninth": "Ninth",
         "tenth": "Tenth"
     },
-    "cellAction": "Click to add image"
+    "cellAction": "Click to add image",
+    "templateListing": {
+        "removeSuccess": "Remove template successfully",
+        "removeFailed": "Remove template failed",
+        "addFailed": "Add template failed",
+        "addSuccess": "Add template successfully",
+        "updateFailed": "Update template failed",
+        "updateSuccess": "Update template successfully"
+    }
 }

package/es/locales/i18n.d.ts

@@ -231,6 +231,14 @@ export declare const translationsJson: {
                 tenth: string;
             };
             cellAction: string;
+            templateListing: {
+                removeSuccess: string;
+                removeFailed: string;
+                addFailed: string;
+                addSuccess: string;
+                updateFailed: string;
+                updateSuccess: string;
+            };
         };
     };
     vi: {
@@ -300,6 +308,14 @@ export declare const translationsJson: {
                 tenth: string;
             };
             close: string;
+            templateListing: {
+                removeSuccess: string;
+                removeFailed: string;
+                addFailed: string;
+                addSuccess: string;
+                updateFailed: string;
+                updateSuccess: string;
+            };
         };
     };
 };

package/es/locales/translations.d.ts

@@ -231,6 +231,14 @@ export declare const convertLanguageJsonToObject: (json: any, objToConvertTo?: C
         tenth: string;
     };
     cellAction: string;
+    templateListing: {
+        removeSuccess: string;
+        removeFailed: string;
+        addFailed: string;
+        addSuccess: string;
+        updateFailed: string;
+        updateSuccess: string;
+    };
 }>, current?: string) => void;
 export declare const t: (id: string, ...rest: any[]) => [string, ...any[]];
 export declare const getTranslateMessage: (id: string, defaultMessage?: string, value?: Record<string, unknown>) => string;

package/es/locales/vi/translation.json

@@ -63,5 +63,13 @@
         "ninth": "thứ chín",
         "tenth": "thứ mười"
     },
-    "close": "Đóng"
+    "close": "Đóng",
+    "templateListing": {
+        "removeSuccess": "Xóa mẫu thành công",
+        "removeFailed": "Xóa mẫu thất bại",
+        "addFailed": "Thêm mẫu thất bại",
+        "addSuccess": "Thêm mẫu thành công",
+        "updateFailed": "Cập nhật mẫu thất bại",
+        "updateSuccess": "Cập nhật mẫu thành công"
+    }
 }

package/es/models/ObjectTemplate.d.ts

@@ -0,0 +1,56 @@
+import dayjs from 'dayjs';
+import { TTemplateStatus } from '../types/templateListing';
+import { Model } from './model';
+import { TShareAccess } from '../types';
+export type TObjectTemplate = {
+    template_id: number;
+    template_name: string;
+    object_type: number;
+    public_level: number;
+    network_id: number;
+    description: string;
+    properties: Record<string, any>;
+    c_user_id: number;
+    u_user_id: number;
+    status: TTemplateStatus;
+    ctime: string;
+    utime: string;
+    thumbnail: string;
+    device_type: number;
+    template_type: number;
+    template_setting: Record<string, any>;
+    config: Record<string, any>;
+    config_object: Record<string, any>;
+    objective: number[];
+    seasonality: number[];
+    industry: number[];
+    goal: number[];
+    journey_type: number[];
+    lifecycle_stage: number[];
+    share_access: TShareAccess;
+};
+export declare class ObjectTemplate extends Model<TObjectTemplate> {
+    get id(): number | "";
+    get name(): string;
+    get type(): number;
+    get typeLabel(): string;
+    get description(): string;
+    get templateSettings(): Record<string, any>;
+    get settings(): Record<string, any>;
+    get status(): "" | TTemplateStatus;
+    get userId(): number | "";
+    get createdAt(): "-" | dayjs.Dayjs;
+    get updatedAt(): "-" | dayjs.Dayjs;
+    get objectiveTypes(): number[];
+    get networkId(): number | undefined;
+    get thumbnail(): string;
+    get objectType(): number | undefined;
+    get config(): Record<string, any> | undefined;
+    get configObject(): Record<string, any> | undefined;
+    get seasonality(): number[] | undefined;
+    get industry(): number[] | undefined;
+    get lifecycleStage(): number[] | undefined;
+    get journeyType(): number[] | undefined;
+    get goal(): number[] | undefined;
+    get shareAccess(): TShareAccess | undefined;
+}