@antscorp/antsomi-ui 1.3.4 → 1.3.5-alpha.2

package/es/types/models/Upload.d.ts

@@ -0,0 +1,34 @@
+import { Model } from './model';
+type TUpload = {
+    url: string;
+    thumbnail: string;
+    file: {
+        path: string;
+    };
+    extension: string;
+    dimensions_file: {
+        height: number;
+        orientation: number;
+        width: number;
+        type: string;
+    };
+    size: number;
+    file_name: string;
+};
+export declare class Upload extends Model<TUpload> {
+    get fileName(): string | undefined;
+    get file(): {
+        path: string;
+    } | undefined;
+    get url(): string;
+    get thumbnail(): string | undefined;
+    get extension(): string;
+    get dimensionsFile(): {
+        height: number;
+        orientation: number;
+        width: number;
+        type: string;
+    } | undefined;
+    get size(): number;
+}
+export {};

package/es/types/providers/AppConfigProvider/contexts/index.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+import { PayloadInfo } from '../../..';
+import { TEnv } from '@antscorp/antsomi-ui/es/types/config';
+export interface AppConfigProps {
+    env?: TEnv;
+    auth?: Omit<PayloadInfo, 'url'>;
+    appCode?: string;
+    menuCode?: string;
+    languageCode?: string;
+    urlLogout?: string;
+    /** Domain */
+    permissionDomain?: string;
+    iamDomain?: string;
+    setAppConfig: React.Dispatch<React.SetStateAction<AppConfigProviderProps>>;
+}
+export interface AppConfigProviderProps extends Omit<AppConfigProps, 'setAppConfig'> {
+}
+declare const AppConfigContext: import("use-context-selector").Context<AppConfigProps>;
+declare const AppConfigProvider: React.FC<React.PropsWithChildren<{
+    value?: AppConfigProviderProps;
+}>>;
+export { AppConfigContext, AppConfigProvider };

package/es/types/providers/AppConfigProvider/index.d.ts

@@ -0,0 +1,2 @@
+export * from './contexts';
+export * from './selector';

package/es/types/providers/AppConfigProvider/selector.d.ts

@@ -0,0 +1,3 @@
+export declare const useAppConfigContext: () => {
+    appConfig: import("./contexts").AppConfigProps;
+};

package/es/types/providers/ConfigProvider/ConfigProvider.d.ts

@@ -0,0 +1,13 @@
+import { ConfigProviderProps as AntdConfigProviderProps } from 'antd/es/config-provider';
+import React, { ReactNode } from 'react';
+import '@antscorp/antsomi-ui/es/assets/css/main.scss';
+import { TLocale } from '@antscorp/antsomi-ui/es/types';
+import 'animate.css';
+import { AppConfigProviderProps } from '../AppConfigProvider';
+interface ConfigProviderProps extends Omit<AntdConfigProviderProps, 'locale'> {
+    children?: ReactNode;
+    locale?: TLocale;
+    appConfig?: AppConfigProviderProps;
+}
+declare const ConfigProvider: React.FC<ConfigProviderProps>;
+export default ConfigProvider;

package/es/types/providers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ConfigProvider';
+export * from './AppConfigProvider';

package/es/types/queries/Account/index.d.ts

@@ -0,0 +1 @@
+export * from './useGetAccountList';

package/es/types/queries/Account/useGetAccountList.d.ts

@@ -0,0 +1,29 @@
+import { UseQueryOptions, UseMutationOptions } from '@tanstack/react-query';
+import { TAccountParams, TUpdateRecentAccount } from '../../services/Account';
+import { AccountListing, AccountRecent, TAccountPermission } from '../../models/AccountListing';
+type OptionHasDefault = 'queryKey' | 'queryFn';
+type GetAccountListProps = {
+    apiConfig: TAccountParams;
+    options?: Omit<UseQueryOptions<AccountListing, any, AccountListing, any[]>, OptionHasDefault>;
+};
+type GetRecentAccountProps = {
+    apiConfig: TAccountParams;
+    options?: Omit<UseQueryOptions<any, any, AccountRecent, any[]>, OptionHasDefault>;
+};
+type UpdateRecentAccountProps = {
+    apiConfig: TAccountParams;
+    options?: UseMutationOptions<{
+        status: number;
+    }, any, TUpdateRecentAccount['data'], unknown>;
+};
+type TCheckUserPermissionProps = {
+    apiConfig: TAccountParams;
+    options?: Omit<UseQueryOptions<any, any, TAccountPermission | undefined, any[]>, OptionHasDefault>;
+};
+export declare const useGetAccountList: (props: GetAccountListProps) => import("@tanstack/react-query").UseQueryResult<AccountListing, any>;
+export declare const useGetRecentAccount: (props: GetRecentAccountProps) => import("@tanstack/react-query").UseQueryResult<AccountRecent, any>;
+export declare const useUpdateRecentAccount: (props: UpdateRecentAccountProps) => import("@tanstack/react-query").UseMutationResult<{
+    status: number;
+}, any, [number, number], unknown>;
+export declare const useCheckUserPermission: (props: TCheckUserPermissionProps) => import("@tanstack/react-query").UseQueryResult<TAccountPermission | undefined, any>;
+export {};

package/es/types/queries/BusinessObject/index.d.ts

@@ -0,0 +1,7 @@
+export * from './useGetListAttributeBO';
+export * from './useGetListEventAttr';
+export * from './useGetListPromotionCodeAttr';
+export * from './useGetListBO';
+export * from './useGetListAllEvents';
+export * from './useGetListSourceByEvent';
+export * from './useGetBODetail';

package/es/types/queries/BusinessObject/useGetBODetail.d.ts

@@ -0,0 +1,5 @@
+import { UseQueryOptions } from '@tanstack/react-query';
+import type { TServiceAuth } from '@antscorp/antsomi-ui/es/types';
+type TDataFnQuery = Record<string, any>;
+export declare const useGetBODetail: <T = TDataFnQuery>(serviceAuth: TServiceAuth, itemTypeId: number | null, queryOptions?: UseQueryOptions<TDataFnQuery, any, T>) => import("@tanstack/react-query").UseQueryResult<T, any>;
+export {};

package/es/types/queries/BusinessObject/useGetDataTableBO.d.ts

@@ -0,0 +1,6 @@
+import type { TServiceAuth } from '../../types';
+export declare const getDataTableBOQuery: (serviceAuth: TServiceAuth, itemTypeId: number | string, params?: Record<string, any>) => Promise<{
+    data: import("../../services/ThirParty/TableBO").TDataTableBO;
+    boId: string | number;
+    params: Record<string, any> | undefined;
+}>;

package/es/types/queries/BusinessObject/useGetListAllEvents.d.ts

@@ -0,0 +1,11 @@
+import { UseQueryOptions } from '@tanstack/react-query';
+import type { APIParams } from '../../components/molecules/AddDynamicContent';
+import type { PayloadInfo } from '../../types';
+type OptionHasDefault = 'queryKey' | 'queryFn';
+type GetListAllEvents<T> = {
+    apiConfig: APIParams;
+    infos: PayloadInfo;
+    options?: Omit<UseQueryOptions<any, any, T, any[]>, OptionHasDefault>;
+};
+export declare const useGetListAllEvents: <T = any>(props: GetListAllEvents<T>) => import("@tanstack/react-query").UseQueryResult<T, any>;
+export {};

package/es/types/queries/BusinessObject/useGetListAttributeBO.d.ts

@@ -0,0 +1,15 @@
+import { UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
+import type { APIParams } from '../../components/molecules/AddDynamicContent';
+import type { PayloadInfo } from '../../types';
+type OptionHasDefault = 'queryKey' | 'queryFn';
+type GetListAttributeBOProps<T> = {
+    itemTypeIds?: number[];
+    options?: Omit<UseQueryOptions<Record<string, any>, any, T, any[]>, OptionHasDefault>;
+};
+export declare const useGetListAttributeBO: <T = Record<string, any>>(apiParams: APIParams, infos: PayloadInfo, props?: GetListAttributeBOProps<T>) => UseQueryResult<T, unknown>;
+export declare const getListAttributeBOQuery: ({ itemTypeIds, url, infos, }: {
+    itemTypeIds: (number | null)[];
+} & APIParams & {
+    infos: PayloadInfo;
+}) => Promise<any>;
+export {};

package/es/types/queries/BusinessObject/useGetListBO.d.ts

@@ -0,0 +1,6 @@
+import { UseQueryOptions } from '@tanstack/react-query';
+import type { APIParams } from '../../components/molecules/AddDynamicContent';
+import type { PayloadInfo } from '../../types';
+type TDataFnQuery = Record<string, any>;
+export declare const useGetListBO: <T = TDataFnQuery>(apiConfig: APIParams, infos: PayloadInfo, queryOptions?: UseQueryOptions<TDataFnQuery, any, T>) => import("@tanstack/react-query").UseQueryResult<T, any>;
+export {};

package/es/types/queries/BusinessObject/useGetListEventAttr.d.ts

@@ -0,0 +1,4 @@
+import { UseQueryOptions } from '@tanstack/react-query';
+import type { APIParams } from '../../components/molecules/AddDynamicContent';
+import type { PayloadInfo } from '../../types';
+export declare const useGetListEventAttr: <T = any[]>(apiConfig: APIParams, infos: PayloadInfo, eventSource: string, sourceId: string, queryOptions?: Omit<UseQueryOptions<any[], any, T>, 'queryKey' | 'queryFn'>) => import("@tanstack/react-query").UseQueryResult<T, any>;

package/es/types/queries/BusinessObject/useGetListPromotionCodeAttr.d.ts

@@ -0,0 +1,6 @@
+import { UseQueryOptions } from '@tanstack/react-query';
+import type { APIParams } from '../../components/molecules/AddDynamicContent';
+import type { PayloadInfo } from '../../types';
+type TQueryFnData = any[];
+export declare const useGetListPromotionCodeAttr: <T = TQueryFnData>(apiConfig: APIParams, infos: PayloadInfo, queryOptions?: Omit<UseQueryOptions<TQueryFnData, any, T>, 'queryKey' | 'queryFn'>) => import("@tanstack/react-query").UseQueryResult<T, any>;
+export {};

package/es/types/queries/BusinessObject/useGetListSourceByEvent.d.ts

@@ -0,0 +1,13 @@
+import { UseQueryOptions } from '@tanstack/react-query';
+import type { APIParams } from '../../components/molecules/AddDynamicContent';
+import type { PayloadInfo } from '../../types';
+type OptionHasDefault = 'queryKey' | 'queryFn';
+type GetListSourceByEvent<T> = {
+    eventCategoryId: number;
+    eventActionId: number;
+    apiConfig: APIParams;
+    infos: PayloadInfo;
+    options?: Omit<UseQueryOptions<any, any, T, any[]>, OptionHasDefault>;
+};
+export declare const useGetListSourceByEvent: <T = any>(props: GetListSourceByEvent<T>) => import("@tanstack/react-query").UseQueryResult<T, any>;
+export {};

package/es/types/queries/CustomFunction/index.d.ts

@@ -0,0 +1,2 @@
+import { useGetCustomFunction, useAddSavedCSFunction, useUpdateCSFunction } from './useCustomFunction';
+export { useGetCustomFunction, useAddSavedCSFunction, useUpdateCSFunction };

package/es/types/queries/CustomFunction/useCustomFunction.d.ts

@@ -0,0 +1,19 @@
+import { UseQueryOptions } from '@tanstack/react-query';
+import { MediaJsonCustomFunction } from '../../models/CustomFunction';
+import type { APIParams } from '../../components/molecules/AddDynamicContent';
+import type { PayloadInfo } from '../../types';
+export declare const useGetCustomFunction: <T = MediaJsonCustomFunction[]>(apiConfig: APIParams, infos: PayloadInfo, queryOptions?: Omit<UseQueryOptions<MediaJsonCustomFunction[], any, T>, 'queryKey' | 'queryFn'>) => import("@tanstack/react-query").UseQueryResult<T, any>;
+export declare const useAddSavedCSFunction: () => import("@tanstack/react-query").UseMutationResult<any, unknown, Partial<any> & {
+    url: string;
+} & Record<string, any> & {
+    infos: PayloadInfo;
+}, {
+    previousSavedBlock: unknown;
+}>;
+export declare const useUpdateCSFunction: () => import("@tanstack/react-query").UseMutationResult<any, unknown, Partial<any> & {
+    url: string;
+} & Record<string, any> & {
+    infos: PayloadInfo;
+}, {
+    previousSavedBlock: unknown;
+}>;

package/es/types/queries/DataTable/index.d.ts

@@ -0,0 +1,99 @@
+import { UseInfiniteQueryOptions, UseMutationOptions, UseQueryOptions } from '@tanstack/react-query';
+import { TCreateModifyColumnArgs, TDeleteModifyColumnArgs, TDeleteSavedFilterArgs, TGetFilterMetricListArgs, TGetMatchesAnyListArgs, TGetMetricListArgs, TGetModifyColumnListArgs, TGetSavedFilterListArgs, TGetSearchListingArgs, TGetTableListingArgs, TSaveFilterArgs, TUpdateFilterArgs, TUpdateModifyColumnArgs } from '../../services/DataTable';
+import { ColumnMetric, FilterMetric, ModifyColumn } from '../../models/DataTable';
+import { SavedFilter } from '../../models/DataTable/SavedFilter';
+import { DataTableListing } from '../../models/DataTable/DataTableListing';
+export type TGetColumnMetrics = {
+    args: TGetMetricListArgs;
+    options?: UseQueryOptions<ColumnMetric[], any, ColumnMetric[], any[]>;
+};
+export type TGetModifyColumnList = {
+    args: TGetModifyColumnListArgs;
+    options?: UseQueryOptions<ModifyColumn[], any, ModifyColumn[], any[]>;
+};
+export type TUpdateModifyColumn = {
+    auth: TUpdateModifyColumnArgs['auth'];
+    options?: UseMutationOptions<{
+        status: number;
+    }, any, TUpdateModifyColumnArgs, unknown>;
+};
+export type TCreateModifyColumn = {
+    auth: TCreateModifyColumnArgs['auth'];
+    options?: UseMutationOptions<{
+        status: number;
+    }, any, TCreateModifyColumnArgs, unknown>;
+};
+export type TDeleteModifyColumn = {
+    auth: TDeleteModifyColumnArgs['auth'];
+    options?: UseMutationOptions<{
+        status: number;
+    }, any, TDeleteModifyColumnArgs, unknown>;
+};
+export type TGetSavedFilterList = {
+    args: TGetSavedFilterListArgs;
+    options?: UseQueryOptions<SavedFilter[], any, SavedFilter[], any[]>;
+};
+export type TGetFilterMetricList = {
+    args: TGetFilterMetricListArgs;
+    options?: UseQueryOptions<FilterMetric[], any, FilterMetric[], any[]>;
+};
+export type TGetMatchesAnyList = {
+    args: TGetMatchesAnyListArgs;
+    options?: UseQueryOptions<any, any, any, any[]>;
+};
+export type TGetInfiniteMatchesAnyList = {
+    args: TGetMatchesAnyListArgs;
+    options?: UseInfiniteQueryOptions<any, any, any, any[]>;
+};
+export type TSaveFilter = {
+    auth: TSaveFilterArgs['auth'];
+    options?: UseMutationOptions<{
+        status: number;
+    }, any, TSaveFilterArgs, any[]>;
+};
+export type TUpdateFilter = {
+    auth: TUpdateFilterArgs['auth'];
+    options?: UseMutationOptions<{
+        status: number;
+    }, any, TUpdateFilterArgs, any[]>;
+};
+export type TDeleteSavedFilter = {
+    auth: TDeleteSavedFilterArgs['auth'];
+    options?: UseMutationOptions<{
+        status: number;
+    }, any, TDeleteSavedFilterArgs, unknown>;
+};
+export type TGetTableListing<T = any> = {
+    args: TGetTableListingArgs;
+    options?: UseQueryOptions<any, any, DataTableListing<T>, any[]>;
+};
+export type TGetSearchListing = {
+    args: TGetSearchListingArgs;
+    options?: UseQueryOptions<any, any, any, any[]>;
+};
+export declare const useGetColumnMetrics: (params: TGetColumnMetrics) => import("@tanstack/react-query").UseQueryResult<ColumnMetric[], any>;
+export declare const useGetModifyColumnList: (params: TGetModifyColumnList) => import("@tanstack/react-query").UseQueryResult<ModifyColumn[], any>;
+export declare const useUpdateModifyColumn: (params?: TUpdateModifyColumn) => import("@tanstack/react-query").UseMutationResult<{
+    status: number;
+}, any, TUpdateModifyColumnArgs, unknown>;
+export declare const useCreateModifyColumn: (params?: TCreateModifyColumn) => import("@tanstack/react-query").UseMutationResult<{
+    status: number;
+}, any, TCreateModifyColumnArgs, unknown>;
+export declare const useDeleteModifyColumn: (params?: TDeleteModifyColumn) => import("@tanstack/react-query").UseMutationResult<{
+    status: number;
+}, any, TDeleteModifyColumnArgs, unknown>;
+export declare const useGetSavedFilterList: (params: TGetSavedFilterList) => import("@tanstack/react-query").UseQueryResult<SavedFilter[], any>;
+export declare const useGetFilterMetricList: (params: TGetFilterMetricList) => import("@tanstack/react-query").UseQueryResult<FilterMetric[], any>;
+export declare const useSaveFilter: (params: TSaveFilter) => import("@tanstack/react-query").UseMutationResult<{
+    status: number;
+}, any, TSaveFilterArgs, any[]>;
+export declare const useUpdateFilter: (params: TUpdateFilter) => import("@tanstack/react-query").UseMutationResult<{
+    status: number;
+}, any, TUpdateFilterArgs, any[]>;
+export declare const useDeleteSavedFilter: (params?: TDeleteSavedFilter) => import("@tanstack/react-query").UseMutationResult<{
+    status: number;
+}, any, TDeleteSavedFilterArgs, unknown>;
+export declare const useGetTableListing: <T>(params: TGetTableListing<T>) => import("@tanstack/react-query").UseQueryResult<DataTableListing<T>, any>;
+export declare const useGetSearchListing: (params: TGetSearchListing) => import("@tanstack/react-query").UseQueryResult<any, any>;
+export declare const useGetMatchesAnyList: (params: TGetMatchesAnyList) => import("@tanstack/react-query").UseQueryResult<any, any>;
+export declare const useGetInfiniteMatchesAnyList: (params: TGetMatchesAnyList) => import("@tanstack/react-query").UseInfiniteQueryResult<any, any>;

package/es/types/queries/DynamicContentAttribute/index.d.ts

@@ -0,0 +1 @@
+export * from './useGetDynamicContentAttr';

package/es/types/queries/DynamicContentAttribute/useGetDynamicContentAttr.d.ts

@@ -0,0 +1,10 @@
+import { UseQueryOptions } from '@tanstack/react-query';
+import { DynamicContentAttribute } from '../../models/DynamicContentAttribute';
+import type { APIParams } from '../../components/molecules/AddDynamicContent';
+import type { PayloadInfo } from '../../types';
+interface TData {
+    visitor: DynamicContentAttribute['visitor'];
+    customer: DynamicContentAttribute['customer'];
+}
+export declare const useGetDynamicContentAttr: <T = TData>(apiConfig: APIParams, infos: PayloadInfo, queryOptions?: Omit<UseQueryOptions<TData, any, T>, 'queryKey' | 'queryFn'>) => import("@tanstack/react-query").UseQueryResult<T, any>;
+export {};

package/es/types/queries/LeftMenu/index.d.ts

@@ -0,0 +1,24 @@
+import { UseQueryOptions } from '@tanstack/react-query';
+import { TFeatureMenuResponse, FeatureMenuPermission, TDestinationChannelResponse, TDashboardResponse } from '../../models/LeftMenu';
+import { TGetDashboardArgs, TGetDestinationChannelArgs, TGetListMenuArgs, TGetListMenuPermissionArgs } from '../../services/LeftMenu';
+export type TGetDashboard = {
+    args: TGetDashboardArgs;
+    options?: UseQueryOptions<any, any, TDashboardResponse, any[]>;
+};
+export type TGetListMenu = {
+    args: TGetListMenuArgs;
+    options?: UseQueryOptions<any, any, TFeatureMenuResponse, any[]>;
+};
+export type TGetListMenuPermission = {
+    args: TGetListMenuPermissionArgs;
+    options?: UseQueryOptions<any, any, FeatureMenuPermission[], any[]>;
+};
+export type TGetDestinationChannel = {
+    args: TGetDestinationChannelArgs;
+    options?: UseQueryOptions<any, any, TDestinationChannelResponse, any[]>;
+};
+export declare const useGetDashboard: (params: TGetDashboard) => import("@tanstack/react-query").UseQueryResult<TDashboardResponse, any>;
+export declare const useRemoveDashboard: () => import("@tanstack/react-query").UseMutationResult<any, unknown, import("../../services/LeftMenu").TRemoveDashboardArgs, unknown>;
+export declare const useGetListMenu: (params: TGetListMenu) => import("@tanstack/react-query").UseQueryResult<TFeatureMenuResponse, any>;
+export declare const useGetListMenuPermission: (params: TGetListMenuPermission) => import("@tanstack/react-query").UseQueryResult<FeatureMenuPermission[], any>;
+export declare const useGetDestinationChannel: (params: TGetDestinationChannel) => import("@tanstack/react-query").UseQueryResult<TDestinationChannelResponse, any>;

package/es/types/queries/Media/index.d.ts

@@ -0,0 +1 @@
+export * from './useGetListingSavedMedia';

package/es/types/queries/Media/useGetListingSavedMedia.d.ts

@@ -0,0 +1,12 @@
+import { UseQueryOptions } from '@tanstack/react-query';
+import { SavedMedia } from '../../models/SavedMedia';
+type OptionHasDefault = 'queryKey' | 'queryFn';
+type GetSavedMediaProps<T> = {
+    domain: any;
+    slug: any;
+    params: any;
+    refresh: number;
+    options?: Omit<UseQueryOptions<any, any, T, any[]>, OptionHasDefault>;
+};
+export declare const useGetListingSavedMedia: <T = SavedMedia[]>(props: GetSavedMediaProps<T>) => import("@tanstack/react-query").UseQueryResult<T, any>;
+export {};

package/es/types/queries/Permission/index.d.ts

@@ -0,0 +1,8 @@
+import { UseQueryOptions } from '@tanstack/react-query';
+import { TGetAccountList } from '../../services/Permission';
+interface GetAccountListProps {
+    args: TGetAccountList;
+    options?: UseQueryOptions<any, any, any[], any[]>;
+}
+export declare const useGetPermissionAccountList: (props: GetAccountListProps) => import("@tanstack/react-query").UseQueryResult<any[], any>;
+export {};

package/es/types/queries/PromotionPool/index.d.ts

@@ -0,0 +1 @@
+export * from './useGetListPromotionPool';

package/es/types/queries/PromotionPool/useGetListPromotionPool.d.ts

@@ -0,0 +1,9 @@
+import { UseQueryOptions } from '@tanstack/react-query';
+import type { APIParams } from '../../components/molecules/AddDynamicContent';
+import type { PayloadInfo } from '../../types';
+interface TReturnData {
+    rows: any[];
+    total: number;
+}
+export declare const useGetListPromotionPool: <T = TReturnData>(apiConfig: APIParams, infos: PayloadInfo, queryOptions?: Omit<UseQueryOptions<TReturnData, any, T>, 'queryKey' | 'queryFn'>) => import("@tanstack/react-query").UseQueryResult<T, any>;
+export {};

package/es/types/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/types/queries/ThirdParty/index.d.ts

@@ -0,0 +1,2 @@
+export * from './useGetEventTrackingAttributes';
+export * from './useGetListFallbackBO';

package/es/types/queries/ThirdParty/useGetEventTrackingAttributes.d.ts

@@ -0,0 +1,14 @@
+import { UseQueryOptions } from '@tanstack/react-query';
+import { EventTrackingAttribute } from '../../models/EventTrackingAttribute';
+import type { APIParams } from '../../components/molecules/AddDynamicContent';
+import type { PayloadInfo } from '../../types';
+type OptionHasDefault = 'queryKey' | 'queryFn';
+type GetDataTableBOProps<T> = {
+    apiConfig: APIParams;
+    infos: PayloadInfo;
+    eventCategoryId: number;
+    eventActionId: number;
+    options?: Omit<UseQueryOptions<any, any, T, any[]>, OptionHasDefault>;
+};
+export declare const useGetEventTrackingAttributes: <T = EventTrackingAttribute>(props: GetDataTableBOProps<T>) => import("@tanstack/react-query").UseQueryResult<T, any>;
+export {};

package/es/types/queries/ThirdParty/useGetListFallbackBO.d.ts

@@ -0,0 +1,10 @@
+import { UseQueryOptions } from '@tanstack/react-query';
+import { FallbackBO } from '@antscorp/antsomi-ui/es/models/FallbackBO';
+import type { TServiceAuth } from '@antscorp/antsomi-ui/es/types';
+type OptionHasDefault = 'queryKey' | 'queryFn';
+type GetDataTableBOProps<T> = {
+    serviceAuth: TServiceAuth;
+    options?: Omit<UseQueryOptions<any, any, T, any[]>, OptionHasDefault>;
+};
+export declare const useGetListFallbackBO: <T = FallbackBO[]>(props: GetDataTableBOProps<T>) => import("@tanstack/react-query").UseQueryResult<T, any>;
+export {};

package/es/types/queries/configs.d.ts

@@ -0,0 +1,4 @@
+import { QueryClientProvider, QueryClient } from '@tanstack/react-query';
+import { ReactQueryDevtools } from '@tanstack/react-query-devtools';
+declare const queryClient: QueryClient;
+export { QueryClientProvider as QueryClientProviderAntsomiUI, QueryClient as QueryClientAntsomiUI, ReactQueryDevtools as QueryDevtoolsAntsomiUI, queryClient as queryClientAntsomiUI, };

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

@@ -0,0 +1,11 @@
+export * from './configs';
+export * from './Account';
+export * from './BusinessObject';
+export * from './CustomFunction';
+export * from './PromotionPool';
+export * from './DynamicContentAttribute';
+export * from './ThirdParty';
+export * from './TemplateListing';
+export * from './Media';
+export * from './Permission';
+export * from './DataTable';

package/es/types/services/Abstract/index.d.ts

@@ -0,0 +1,15 @@
+declare const AbstractService: {
+    lookupInfo: {
+        callApi: {
+            c_user_id: ({ params, search }: {
+                params?: {} | undefined;
+                search: any;
+            }) => Promise<any[]>;
+            list_account: ({ params, search }: {
+                params?: {} | undefined;
+                search: any;
+            }) => Promise<any[]>;
+        };
+    };
+};
+export default AbstractService;

package/es/types/services/Account/index.d.ts

@@ -0,0 +1,21 @@
+import { AccountListing, AccountRecent, TAccountPermission } from '../../models/AccountListing';
+export type TAccountParams = {
+    domain: string;
+    portalId?: number;
+    languageCode?: string;
+    userId?: number;
+    accountId?: number;
+    token?: string;
+};
+export type TUpdateRecentAccount = {
+    params: TAccountParams;
+    data: [number, number];
+};
+export declare const accountService: {
+    getList: (config: TAccountParams) => Promise<AccountListing>;
+    getRecentAccount: (config: TAccountParams) => Promise<AccountRecent | undefined>;
+    checkPermission: (config: TAccountParams) => Promise<TAccountPermission>;
+    updateRecentAccount: (args: TUpdateRecentAccount) => Promise<{
+        status: number;
+    }>;
+};