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

package/es/models/ObjectTemplate.js

@@ -0,0 +1,82 @@
+// Libraries
+import dayjs from 'dayjs';
+// Models
+import { Model } from './model';
+// Constants
+import { DATE_TIME_FORMAT, LAYOUT_TEMPLATE } from '../constants';
+export class ObjectTemplate extends Model {
+    get id() {
+        return this.model.template_id || '';
+    }
+    get name() {
+        return this.model.template_name || '';
+    }
+    get type() {
+        return +(this.model.template_type || '');
+    }
+    get typeLabel() {
+        const templateType = Object.values(LAYOUT_TEMPLATE).find(({ id }) => id === this.type);
+        return templateType ? templateType.label : '';
+    }
+    get description() {
+        return this.model.description || '';
+    }
+    get templateSettings() {
+        return this.model.template_setting || {};
+    }
+    get settings() {
+        return this.model.properties || {};
+    }
+    get status() {
+        return this.model.status || '';
+    }
+    get userId() {
+        return this.model.c_user_id || '';
+    }
+    get createdAt() {
+        return dayjs(this.model.ctime).isValid()
+            ? dayjs(this.model.ctime, DATE_TIME_FORMAT.DATE_TIME)
+            : '-';
+    }
+    get updatedAt() {
+        return dayjs(this.model.utime).isValid()
+            ? dayjs(this.model.utime, DATE_TIME_FORMAT.DATE_TIME)
+            : '-';
+    }
+    get objectiveTypes() {
+        return this.model.goal || [];
+    }
+    get networkId() {
+        return this.model.network_id;
+    }
+    get thumbnail() {
+        return this.model.thumbnail || '';
+    }
+    get objectType() {
+        return this.model.object_type;
+    }
+    get config() {
+        return this.model.config;
+    }
+    get configObject() {
+        return this.model.config_object;
+    }
+    get seasonality() {
+        return this.model.seasonality;
+    }
+    get industry() {
+        return this.model.industry;
+    }
+    get lifecycleStage() {
+        return this.model.lifecycle_stage;
+    }
+    get journeyType() {
+        return this.model.journey_type;
+    }
+    get goal() {
+        return this.model.goal;
+    }
+    get shareAccess() {
+        return this.model.share_access;
+    }
+}

package/es/models/TemplateCategory.d.ts

@@ -0,0 +1,13 @@
+import { TObjectType } from '../types/templateListing';
+export type TTemplateCategory = {};
+export interface TemplateCategory {
+    categoryId: number;
+    categoryCode: string;
+    parentCategoryCode: string;
+    categoryName: string;
+    description: string;
+    objectTypes: TObjectType[];
+    filterOperator?: string;
+    children: TemplateCategory[];
+    total?: number;
+}

package/es/models/TemplateCategory.js

@@ -0,0 +1,28 @@
+export {};
+// export class TemplateCategory extends Model<TTemplateCategory> {
+//   get id() {
+//     return this.model.media_id || '';
+//   }
+//   get name() {
+//     return this.model.name || '';
+//   }
+//   get url() {
+//     return this.model.properties?.url || '';
+//   }
+//   get thumbnail() {
+//     return this.model.properties?.thumbnail || '';
+//   }
+//   get createdAt() {
+//     return moment(this.model.ctime, true).isValid() ? moment(this.model.ctime) : null;
+//   }
+//   get size() {
+//     return +(this.model.properties?.size || 0);
+//   }
+//   get sizeString() {
+//     const { properties } = this.model;
+//     const dimensionsFile = properties?.dimensions_file;
+//     return `${Math.round(10 * ((properties?.size || 0) / 1024)) / 10} KB, ${
+//       dimensionsFile?.width
+//     } x ${dimensionsFile?.height} `;
+//   }
+// }

package/es/queries/CustomFunction/useCustomFunction.js

@@ -8,46 +8,46 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 // Libraries
-import { useMutation, useQuery } from '@tanstack/react-query';
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
 // Services
 import { getListingTemplateCustomFunction, createSavedCustomFunction, updateSavedCustomFunction, } from '../../services/MediaTemplateDesign/CustomFunction';
 // Constants
 import { QUERY_KEYS } from '../../constants/queries';
-// Query client
-import { queryClientAntsomiUI } from '../configs';
 export const useGetCustomFunction = (apiConfig, infos, queryOptions) => useQuery(Object.assign({ queryKey: [QUERY_KEYS.GET_LIST_CUSTOM], queryFn: () => __awaiter(void 0, void 0, void 0, function* () {
         const data = yield getListingTemplateCustomFunction({ url: apiConfig.url }, infos);
         return data;
     }) }, queryOptions));
-export const useAddSavedCSFunction = () => useMutation(createSavedCustomFunction, {
-    onMutate: (_payload) => {
-        const previousSavedBlock = queryClientAntsomiUI.getQueryData([
-            QUERY_KEYS.GET_SAVE_CUSTOM_FUNCTION,
-        ]);
-        return { previousSavedBlock };
-    },
-    onError: (_error, _payload, context) => {
-        queryClientAntsomiUI.setQueryData([QUERY_KEYS.GET_SAVE_CUSTOM_FUNCTION], context === null || context === void 0 ? void 0 : context.previousSavedBlock);
-    },
-    onSettled: () => {
-        queryClientAntsomiUI.invalidateQueries([QUERY_KEYS.GET_SAVE_CUSTOM_FUNCTION], {
-            exact: true,
-        });
-    },
-});
-export const useUpdateCSFunction = () => useMutation(updateSavedCustomFunction, {
-    onMutate: (_payload) => {
-        const previousSavedBlock = queryClientAntsomiUI.getQueryData([
-            QUERY_KEYS.GET_SAVE_CUSTOM_FUNCTION,
-        ]);
-        return { previousSavedBlock };
-    },
-    onError: (_error, _payload, context) => {
-        queryClientAntsomiUI.setQueryData([QUERY_KEYS.GET_SAVE_CUSTOM_FUNCTION], context === null || context === void 0 ? void 0 : context.previousSavedBlock);
-    },
-    onSettled: () => {
-        queryClientAntsomiUI.invalidateQueries([QUERY_KEYS.GET_SAVE_CUSTOM_FUNCTION], {
-            exact: true,
-        });
-    },
-});
+export const useAddSavedCSFunction = () => {
+    const queryClient = useQueryClient();
+    return useMutation(createSavedCustomFunction, {
+        onMutate: (_payload) => {
+            const previousSavedBlock = queryClient.getQueryData([QUERY_KEYS.GET_SAVE_CUSTOM_FUNCTION]);
+            return { previousSavedBlock };
+        },
+        onError: (_error, _payload, context) => {
+            queryClient.setQueryData([QUERY_KEYS.GET_SAVE_CUSTOM_FUNCTION], context === null || context === void 0 ? void 0 : context.previousSavedBlock);
+        },
+        onSettled: () => {
+            queryClient.invalidateQueries([QUERY_KEYS.GET_SAVE_CUSTOM_FUNCTION], {
+                exact: true,
+            });
+        },
+    });
+};
+export const useUpdateCSFunction = () => {
+    const queryClient = useQueryClient();
+    return useMutation(updateSavedCustomFunction, {
+        onMutate: (_payload) => {
+            const previousSavedBlock = queryClient.getQueryData([QUERY_KEYS.GET_SAVE_CUSTOM_FUNCTION]);
+            return { previousSavedBlock };
+        },
+        onError: (_error, _payload, context) => {
+            queryClient.setQueryData([QUERY_KEYS.GET_SAVE_CUSTOM_FUNCTION], context === null || context === void 0 ? void 0 : context.previousSavedBlock);
+        },
+        onSettled: () => {
+            queryClient.invalidateQueries([QUERY_KEYS.GET_SAVE_CUSTOM_FUNCTION], {
+                exact: true,
+            });
+        },
+    });
+};

package/es/queries/TemplateListing/index.d.ts

@@ -0,0 +1,52 @@
+import { UseInfiniteQueryOptions, UseMutationOptions, UseQueryOptions } from '@tanstack/react-query';
+import { TemplateCategory } from '@antscorp/antsomi-ui/es/models/TemplateCategory';
+import { TBulkUpdateObjectTemplateArgs, TGetCategoryListArgs, TGetObjectTemplateDetailArgs, TGetObjectTemplateListArgs, TGetSaveAsGalleryPermissionArgs, TUpdateObjectTemplateArgs, TValidateObjectTemplateNameArgs } from '@antscorp/antsomi-ui/es/services/TemplateListing';
+import { ResponseCheckNameExist, ResponseListing } from '../../types';
+import { ObjectTemplate } from '../../models/ObjectTemplate';
+import { TCreateObjectTemplateArgs } from '../../services/TemplateListing';
+export type TGetTemplateCategoryList = {
+    args: TGetCategoryListArgs;
+    options?: UseQueryOptions<any, any, TemplateCategory[], any[]>;
+};
+export type TGetSaveAsGalleryPermissionEmails = {
+    args: TGetSaveAsGalleryPermissionArgs;
+    options?: UseQueryOptions<any, any, string[], any[]>;
+};
+export type TGetObjectTEmplateList = {
+    args: TGetObjectTemplateListArgs;
+    options?: UseInfiniteQueryOptions<any, any, ResponseListing<ObjectTemplate>, (string | number)[]>;
+};
+export type TGetObjectTemplateDetail = {
+    args: TGetObjectTemplateDetailArgs;
+    options?: UseQueryOptions<ObjectTemplate, any, ObjectTemplate, any[]>;
+};
+export type TBulkUpdateTemplate = {
+    options?: UseMutationOptions<any, any, TBulkUpdateObjectTemplateArgs, unknown>;
+};
+export type TUseCreateTemplate = {
+    options?: UseMutationOptions<any, any, TCreateObjectTemplateArgs, unknown>;
+};
+export type TUseUpdateTemplate = {
+    options?: UseMutationOptions<any, any, TUpdateObjectTemplateArgs, unknown>;
+};
+export type TUseValidateTemplateName = {
+    options?: UseMutationOptions<ResponseCheckNameExist, any, TValidateObjectTemplateNameArgs, unknown>;
+};
+export type TUsePersistTemplate = {
+    options?: UseMutationOptions<ObjectTemplate, any, {
+        persistType: 'create' | 'update';
+        params: TUpdateObjectTemplateArgs;
+    }, unknown>;
+};
+export declare const useGetTemplateCategoryList: (params: TGetTemplateCategoryList) => import("@tanstack/react-query").UseQueryResult<TemplateCategory[], any>;
+export declare const useGetSaveAsGalleryPermissionEmails: (params: TGetSaveAsGalleryPermissionEmails) => import("@tanstack/react-query").UseQueryResult<string[], any>;
+export declare const useGetObjectTemplateList: (params: TGetObjectTEmplateList) => import("@tanstack/react-query").UseInfiniteQueryResult<ResponseListing<ObjectTemplate>, any>;
+export declare const useGetObjectTemplateDetail: (params: TGetObjectTemplateDetail) => import("@tanstack/react-query").UseQueryResult<ObjectTemplate, any>;
+export declare const useValidateTemplateName: (params: TUseValidateTemplateName) => import("@tanstack/react-query").UseMutationResult<ResponseCheckNameExist, any, TValidateObjectTemplateNameArgs, unknown>;
+export declare const useBulkUpdateTemplate: (params: TBulkUpdateTemplate) => import("@tanstack/react-query").UseMutationResult<any, any, TBulkUpdateObjectTemplateArgs, unknown>;
+export declare const useCreateTemplate: (params: TUseCreateTemplate) => import("@tanstack/react-query").UseMutationResult<any, any, TCreateObjectTemplateArgs, unknown>;
+export declare const useUpdateTemplate: (params: TUseUpdateTemplate) => import("@tanstack/react-query").UseMutationResult<any, any, TUpdateObjectTemplateArgs, unknown>;
+export declare const usePersistTemplate: (params: TUsePersistTemplate) => import("@tanstack/react-query").UseMutationResult<ObjectTemplate, any, {
+    persistType: 'create' | 'update';
+    params: TUpdateObjectTemplateArgs;
+}, unknown>;

package/es/queries/TemplateListing/index.js

@@ -0,0 +1,105 @@
+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 { useInfiniteQuery, useMutation, useQuery, useQueryClient, } from '@tanstack/react-query';
+import { get, omit } from 'lodash';
+// Services
+import { templateListingServices, } from '@antscorp/antsomi-ui/es/services/TemplateListing';
+// Constants
+import { QUERY_KEYS } from '../../constants/queries';
+const { category, objectTemplate } = templateListingServices;
+export const useGetTemplateCategoryList = (params) => {
+    const { options, args } = params;
+    return useQuery(Object.assign({ queryKey: [QUERY_KEYS.GET_TEMPLATE_CATEGORY_LIST, args.params], queryFn: () => category.getList(params.args), onSuccess() { } }, options));
+};
+export const useGetSaveAsGalleryPermissionEmails = (params) => {
+    const { options } = params;
+    return useQuery(Object.assign({ queryKey: [QUERY_KEYS.GET_SAVE_AS_GALLERY_PERMISSION_EMAILS], queryFn: () => objectTemplate.getSaveAsGalleryPermission(params.args), onSuccess() { } }, options));
+};
+export const useGetObjectTemplateList = (params) => {
+    const { options, args } = params;
+    return useInfiniteQuery(Object.assign({ queryKey: [QUERY_KEYS.GET_OBJECT_TEMPLATE_LIST, args.params], queryFn: ({ pageParam = 1 }) => __awaiter(void 0, void 0, void 0, function* () {
+            const res = yield objectTemplate.getList(Object.assign(Object.assign({}, args), { params: Object.assign(Object.assign({}, args.params), { page: pageParam }) }));
+            return res;
+        }), getNextPageParam: lastPage => {
+            const { meta } = lastPage;
+            const { currentPage, totalPages } = meta;
+            return +currentPage < +totalPages ? Number(lastPage.meta.currentPage) + 1 : undefined;
+        } }, options));
+};
+export const useGetObjectTemplateDetail = (params) => {
+    const { args, options } = params;
+    return useQuery(Object.assign({ queryKey: [QUERY_KEYS.GET_OBJECT_TEMPLATE_DETAIL, +args.params.template_id], queryFn: () => objectTemplate.getDetail(args), enabled: !!args.params.template_id }, options));
+};
+export const useValidateTemplateName = (params) => {
+    const { options } = params;
+    return useMutation(Object.assign({ mutationFn: objectTemplate.validateName }, options));
+};
+export const useBulkUpdateTemplate = (params) => {
+    const { options } = params;
+    const queryClient = useQueryClient();
+    return useMutation(Object.assign({ mutationFn: objectTemplate.bulkUpdate, onSettled() {
+            queryClient.invalidateQueries([QUERY_KEYS.GET_OBJECT_TEMPLATE_LIST], {
+                exact: false,
+            });
+            queryClient.invalidateQueries([QUERY_KEYS.GET_TEMPLATE_CATEGORY_LIST], {
+                exact: false,
+            });
+        } }, options));
+};
+export const useCreateTemplate = (params) => {
+    const { options } = params;
+    const queryClient = useQueryClient();
+    return useMutation(Object.assign({ mutationFn: objectTemplate.create, onSettled() {
+            queryClient.invalidateQueries([QUERY_KEYS.GET_OBJECT_TEMPLATE_LIST], {
+                exact: false,
+            });
+            queryClient.invalidateQueries([QUERY_KEYS.GET_TEMPLATE_CATEGORY_LIST], {
+                exact: false,
+            });
+        } }, options));
+};
+export const useUpdateTemplate = (params) => {
+    const { options } = params;
+    const queryClient = useQueryClient();
+    return useMutation(Object.assign({ mutationFn: objectTemplate.update, onSettled() {
+            queryClient.invalidateQueries([QUERY_KEYS.GET_OBJECT_TEMPLATE_LIST], {
+                exact: false,
+            });
+            queryClient.invalidateQueries([QUERY_KEYS.GET_TEMPLATE_CATEGORY_LIST], {
+                exact: false,
+            });
+        } }, options));
+};
+export const usePersistTemplate = (params) => {
+    const { options } = params;
+    const queryClient = useQueryClient();
+    return useMutation(Object.assign({ mutationFn: (args) => {
+            const { persistType, params } = args;
+            switch (persistType) {
+                case 'update':
+                    return objectTemplate.update(params);
+                case 'create':
+                default:
+                    return objectTemplate.create(Object.assign(Object.assign({}, params), { data: omit(params.data, ['template_id']) }));
+            }
+        }, onSettled(data, error, variables) {
+            queryClient.invalidateQueries([
+                QUERY_KEYS.GET_OBJECT_TEMPLATE_DETAIL,
+                +get(variables, 'params.data.template_id', -1),
+            ]);
+            queryClient.invalidateQueries([QUERY_KEYS.GET_OBJECT_TEMPLATE_LIST], {
+                exact: false,
+            });
+            queryClient.invalidateQueries([QUERY_KEYS.GET_TEMPLATE_CATEGORY_LIST], {
+                exact: false,
+            });
+        } }, options));
+};

package/es/queries/index.d.ts

@@ -4,3 +4,4 @@ export * from './CustomFunction';
 export * from './PromotionPool';
 export * from './DynamicContentAttribute';
 export * from './ThirdParty';
+export * from './TemplateListing';

package/es/queries/index.js

@@ -4,3 +4,4 @@ export * from './CustomFunction';
 export * from './PromotionPool';
 export * from './DynamicContentAttribute';
 export * from './ThirdParty';
+export * from './TemplateListing';

package/es/services/TemplateListing/index.d.ts

@@ -0,0 +1,70 @@
+import { PaginationRequest, PayloadInfo, ResponseCheckNameExist, ResponseListing, TGetListType, TServiceAuth } from '../../types';
+import { TObjectType, TPublicLevel } from '../../types/templateListing';
+import { TThumbnailCardId } from '../../components/molecules/ThumbnailCard';
+import { TemplateCategory } from '../../models/TemplateCategory';
+import { ObjectTemplate, TObjectTemplate } from '../../models/ObjectTemplate';
+export type TGetCategoryListArgs = {
+    params: {
+        objectTypes: TObjectType[];
+        categoryCodes?: string[];
+        publicLevel?: TPublicLevel;
+        getListType?: TGetListType;
+    };
+    auth: PayloadInfo;
+};
+export type TGetObjectTemplateDetailArgs = {
+    params: {
+        template_id: TThumbnailCardId;
+        object_type: TObjectType;
+        public_level: TPublicLevel;
+    };
+    auth: PayloadInfo;
+};
+export type TGetObjectTemplateListArgs = {
+    params: {
+        object_type: TObjectType;
+        public_level: TPublicLevel;
+        get_list_type: TGetListType;
+    } & PaginationRequest;
+    auth: TServiceAuth;
+};
+export type TBulkUpdateObjectTemplateArgs = {
+    params: {
+        template_ids: number[];
+        data: Partial<TObjectTemplate>;
+    };
+    auth: TServiceAuth;
+};
+export type TUpdateObjectTemplateArgs = {
+    data: Partial<TObjectTemplate>;
+    auth: TServiceAuth;
+};
+export type TCreateObjectTemplateArgs = {
+    data: Partial<TObjectTemplate>;
+    auth: TServiceAuth;
+};
+export type TGetSaveAsGalleryPermissionArgs = {
+    auth: TServiceAuth;
+};
+export type TValidateObjectTemplateNameArgs = {
+    params: {
+        template_name: string;
+        object_type: TObjectType;
+        public_level: TPublicLevel;
+    };
+    auth: TServiceAuth;
+};
+export declare const templateListingServices: {
+    category: {
+        getList: ({ params, auth }: TGetCategoryListArgs) => Promise<TemplateCategory[]>;
+    };
+    objectTemplate: {
+        getList: ({ params, auth, }: TGetObjectTemplateListArgs) => Promise<ResponseListing<ObjectTemplate>>;
+        getDetail: ({ params, auth }: TGetObjectTemplateDetailArgs) => Promise<ObjectTemplate>;
+        create: ({ data, auth }: TCreateObjectTemplateArgs) => Promise<ObjectTemplate>;
+        update: ({ data, auth }: TUpdateObjectTemplateArgs) => Promise<ObjectTemplate>;
+        bulkUpdate: ({ params, auth }: TBulkUpdateObjectTemplateArgs) => Promise<any>;
+        validateName: ({ params, auth, }: TValidateObjectTemplateNameArgs) => Promise<ResponseCheckNameExist>;
+        getSaveAsGalleryPermission: ({ auth, }: TGetSaveAsGalleryPermissionArgs) => Promise<string[]>;
+    };
+};

package/es/services/TemplateListing/index.js

@@ -0,0 +1,161 @@
+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());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+// Libraries
+import { get } from 'lodash';
+import isEmpty from 'lodash/isEmpty';
+// Services
+// Types
+import axios from 'axios';
+import { ObjectTemplate } from '../../models/ObjectTemplate';
+const TEMPLATE_CATEGORY_ROUTE = 'template-category/index';
+const OBJECT_TEMPLATE_ROUTE = 'object_template';
+export const templateListingServices = {
+    category: {
+        getList: ({ params, auth }) => __awaiter(void 0, void 0, void 0, function* () {
+            try {
+                const { objectTypes = [], categoryCodes, publicLevel, getListType } = params;
+                const response = yield axios({
+                    method: 'GET',
+                    url: `${auth.url}/${TEMPLATE_CATEGORY_ROUTE}`,
+                    params: Object.assign({ _token: auth.token, _user_id: auth.userId, _account_id: auth.accountId, objectTypes: objectTypes.join(','), publicLevel: publicLevel !== null && publicLevel !== void 0 ? publicLevel : 0, getListType }, (!isEmpty(categoryCodes) ? { categoryCodes: categoryCodes === null || categoryCodes === void 0 ? void 0 : categoryCodes.join(',') } : {})),
+                });
+                return get(response, 'data.data', []);
+            }
+            catch (error) {
+                return Promise.reject(error);
+            }
+        }),
+    },
+    objectTemplate: {
+        getList: ({ params, auth, }) => __awaiter(void 0, void 0, void 0, function* () {
+            try {
+                const response = yield axios({
+                    method: 'GET',
+                    url: `${auth.url}/${OBJECT_TEMPLATE_ROUTE}`,
+                    params: Object.assign({ _token: auth.token, _user_id: auth.userId, _account_id: auth.accountId }, params),
+                });
+                const { entities, meta } = get(response, 'data.data', {});
+                return {
+                    entities: entities.map(entity => new ObjectTemplate(entity)),
+                    meta,
+                };
+            }
+            catch (error) {
+                return Promise.reject(error);
+            }
+        }),
+        getDetail: ({ params, auth }) => __awaiter(void 0, void 0, void 0, function* () {
+            try {
+                const { template_id } = params, restOfPrams = __rest(params, ["template_id"]);
+                const response = yield axios({
+                    method: 'GET',
+                    url: `${auth.url}/${OBJECT_TEMPLATE_ROUTE}/${template_id}`,
+                    params: Object.assign({ _token: auth.token, _user_id: auth.userId, _account_id: auth.accountId }, restOfPrams),
+                });
+                return new ObjectTemplate(get(response, 'data.data', {}));
+            }
+            catch (error) {
+                return Promise.reject(error);
+            }
+        }),
+        create: ({ data, auth }) => __awaiter(void 0, void 0, void 0, function* () {
+            try {
+                const response = yield axios({
+                    method: 'POST',
+                    url: `${auth.url}/${OBJECT_TEMPLATE_ROUTE}`,
+                    params: {
+                        _token: auth.token,
+                        _user_id: auth.userId,
+                        _account_id: auth.accountId,
+                    },
+                    data,
+                });
+                return new ObjectTemplate(get(response, 'data.data', {}));
+            }
+            catch (error) {
+                return Promise.reject(error);
+            }
+        }),
+        update: ({ data, auth }) => __awaiter(void 0, void 0, void 0, function* () {
+            try {
+                const { template_id } = data, restOfData = __rest(data, ["template_id"]);
+                const response = yield axios({
+                    method: 'PUT',
+                    url: `${auth.url}/${OBJECT_TEMPLATE_ROUTE}/${template_id}`,
+                    params: {
+                        _token: auth.token,
+                        _user_id: auth.userId,
+                        _account_id: auth.accountId,
+                    },
+                    data: restOfData,
+                });
+                return new ObjectTemplate(get(response, 'data.data', {}));
+            }
+            catch (error) {
+                return Promise.reject(error);
+            }
+        }),
+        bulkUpdate: ({ params, auth }) => __awaiter(void 0, void 0, void 0, function* () {
+            try {
+                const response = yield axios({
+                    method: 'POST',
+                    url: `${auth.url}/${OBJECT_TEMPLATE_ROUTE}/bulk-update`,
+                    params: {
+                        _token: auth.token,
+                        _user_id: auth.userId,
+                        _account_id: auth.accountId,
+                        template_ids: (params.template_ids || []).join(','),
+                    },
+                    data: params.data,
+                });
+                return get(response, 'data.data', {});
+            }
+            catch (error) {
+                return Promise.reject(error);
+            }
+        }),
+        validateName: ({ params, auth, }) => __awaiter(void 0, void 0, void 0, function* () {
+            try {
+                const response = yield axios({
+                    method: 'POST',
+                    url: `${auth.url}/${OBJECT_TEMPLATE_ROUTE}/validate-name`,
+                    params: Object.assign({ _token: auth.token, _user_id: auth.userId, _account_id: auth.accountId }, params),
+                });
+                return get(response, 'data.data', {});
+            }
+            catch (error) {
+                return Promise.reject(error);
+            }
+        }),
+        getSaveAsGalleryPermission: ({ auth, }) => __awaiter(void 0, void 0, void 0, function* () {
+            try {
+                const response = yield axios({
+                    method: 'GET',
+                    url: `${auth.url}/${OBJECT_TEMPLATE_ROUTE}/save-as-gallery-permission-emails`,
+                });
+                return get(response, 'data.data', []);
+            }
+            catch (error) {
+                return Promise.reject(error);
+            }
+        }),
+    },
+};