tradly/Roots/App.js

Tradly JS SDK

import network, { Method } from "./../NetworkManager/NetworkManager.js";
import {
	ACCOUNTS,
	ATTRIBUTE,
	DEVICES,
	REPORT,
	CATEGORY,
	CURRENCY,
	HOME,
	USERS,
	BLOCK,
	SEARCHADDRESS,
	LANGUAGES,
	LIKE,
	LISTINGS,
	ORDERS,
	REVIEW,
	PAYMENTSMETHODS,
	ADDRESS,
	FOLLOW,
	COLLECTIONS,
	PROMO,
	SHIPPINGMETHOD,
	VARIANTS,
	CART,
	CHECKOUT,
	VALUES,
	TRANSACTIONS,
	EARNINGS,
	VARIANTTYPES,
	EPHERMERALKEY,
	PAYMENTINTENT,
	CONFIGLIST,
	STATUS,
	S3SIGNEDURL,
	STRIPECONNECTACCOUNT,
	CREATEACCOUNTLINK,
	CREATEEXPRESSLOGINLINK,
	SCHEDULE,
	SCHEDULEPERDAY,
	COUNTRIES,
	TENANTSCOUNTRIES,
	SLUG,
	BLOCKEDACCOUNT,
	FOLLOWINGACCOUNT,
	LAYER,
	FOLLOWINGLISTING,
	GROUPCONFIGLIST,
	TENANTSHIPPINGMETHOD,
	LISTINGSUNIQUELOCATIONS,
	TENANTLANGUAGES,
	CLIENTTRANSLATION_GROUPS,
	CLIENTTRANSLATION_VALUES,
	CLIENTTRANSLATION_VALUES_GROUP,
	PLACES_ADDRESS,
	PLACES_ADDRESS_DETAIL,
	FEEDBACK_CATEGORIES,
	CREATE_FEEDBACK,
	GET_COMMENTS,
	CREATE_COMMENTS,
	COUPON,
	ACTIVITIES,
	COMMISSIONS,
	LOGOUT,
	SUBSCRIPTION,
	SUBSCRIPTION_CONFIRM,
	SUBSCRIPTION_MANAGE,
	MANGO_PAY,
	TIME_SLOT,
	OPP_MERCHANT,
	DIGITAL_CONTENT,
	S3SIGNEDGETURL,
	COLLECTIONS_DATA,
	ACCOUNTSUNIQUELOCATIONS,
	NEGOTIATE,
	SSO_RETURN,
	SSO_ENABLED,
	TRANSLATIONS,
	WALLET,
	SAVED_CARD,
	SHIPMENTS,
	STATES,
	SUBSCRIPTION_LISTINGS,
	TAX,
	UNLIKE,
	AI_SERVICES,
} from "./../Constants/PathConstant.js";
import serialization from "../Helper/Serialization.js";
import { ImageConfig } from "../Helper/APIParam.js";
import { APPCONSTANT } from "../Constants/AppConstant.js";

class App {
	async deleteUser(param = { id, authKey }) {
		let path = USERS + `/${param.id}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: path,
				method: Method.DELETE,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async getCountries() {
		try {
			const [error, responseJson] = await network.networkCall({
				path: COUNTRIES,
				method: Method.GET,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async getTenantCountries(param = { authKey }) {
		try {
			const [error, responseJson] = await network.networkCall({
				path: TENANTSCOUNTRIES,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async getConfigList(param = { paramBody, authKey, domain_id }) {
		let url = `${CONFIGLIST}${param.paramBody}&domain_id=${APPCONSTANT.DOMAIN_ID}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: url,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async getGroupedConfigList(param = { paramBody, authKey, domain_id }) {
		let url = `${GROUPCONFIGLIST}${param.paramBody}&domain_id=${APPCONSTANT.DOMAIN_ID}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: url,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async getGroupedSecureConfigList(
		param = { paramBody, authKey, domain_id, barrow_access_key }
	) {
		let url = `${GROUPCONFIGLIST}${param.paramBody}&domain_id=${APPCONSTANT.DOMAIN_ID}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: url,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
				barrow_access_key: param.access_key,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async updateDeviceInfo(param = { data, authKey }) {
		try {
			const [error, responseJson] = await network.networkCall({
				path: DEVICES,
				method: Method.PUT,
				param: param.data,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async updateUserInfo(param = { id, data, authKey }) {
		try {
			const [error, responseJson] = await network.networkCall({
				path: USERS + `/${param.id}`,
				method: Method.PATCH,
				param: param.data,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async home(param = { authKey }) {
		try {
			const [error, responseJson] = await network.networkCall({
				path: HOME,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}

	// Language

	async getLanguages(param = { authKey }) {
		try {
			const [error, responseJson] = await network.networkCall({
				path: LANGUAGES,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}

	async getTenantLanguages(param = { authKey }) {
		try {
			const [error, responseJson] = await network.networkCall({
				path: TENANTLANGUAGES,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}

	//
	async generateS3ImageURL(param = { authKey, data }) {
		try {
			const [error, responseJson] = await network.networkCall({
				path: S3SIGNEDURL,
				method: Method.POST,
				param: param.data,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async uploadS3Image(param = ImageConfig) {
		try {
			const [error, responseJson] = await network.uploadImage(
				param
			);
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}

	async getS3SignedURL(param = { authKey, data }) {
		try {
			const [error, responseJson] = await network.networkCall({
				path: S3SIGNEDGETURL,
				method: Method.POST,
				param: param.data,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}

	// User Details
	async getUserDetail(param = { authKey, id }) {
		try {
			const [error, responseJson] = await network.networkCall({
				path: USERS + `/${param.id}`,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async getUserProfile(param = { authKey, id }) {
		try {
			const [error, responseJson] = await network.networkCall({
				path: USERS + `/profile`,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async getUsersList(param = { bodyParam, authKey }) {
		let url =
			param.bodyParam == undefined || param.bodyParam == ""
				? ""
				: `?${serialization(param.bodyParam)}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: USERS + url,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}

	//  user follow
	async userFollow(param = { authKey, data }) {
		try {
			const [error, responseJson] = await network.networkCall({
				path: USERS + `/followings`,
				method: Method.POST,
				param: param.data,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}

	// user followings
	async getUserFollowings(param = { bodyParam, authKey }) {
		let url =
			param.bodyParam == undefined || param.bodyParam == ""
				? ""
				: `?${serialization(param.bodyParam)}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: USERS + `/followings/user` + url,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}

	// user followers
	async getUserFollowers(param = { bodyParam, authKey }) {
		let url =
			param.bodyParam == undefined || param.bodyParam == ""
				? ""
				: `?${serialization(param.bodyParam)}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: USERS + `/followers/user` + url,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	// get user attributes
	async getUserAttributes(param = { authKey, id, recaptcha_token }) {
		try {
			const [error, responseJson] = await network.networkCall({
				path:
					USERS +
					`/${param.id}/profile?recaptcha_token=${param.recaptcha_token}`,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	//MARK:-  ADDRESS APIS  
	async addEditAddress(param = { id, data, authKey }) {
		let path =
			param.id == undefined || param.id == ""
				? ADDRESS
				: ADDRESS + `/${param.id}`;
		let method =
			param.id == undefined || param.id == ""
				? Method.POST
				: Method.PUT;
		try {
			const [error, responseJson] = await network.networkCall({
				path: path,
				method: method,
				param: param.data,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async getAddress(param = { bodyParam, authKey }) {
		let url =
			param.bodyParam == undefined || param.bodyParam == ""
				? ""
				: `?${serialization(param.bodyParam)}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: ADDRESS + url,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}

	//
	async getStates(param = { bodyParam, authKey }) {
		let url =
			param.bodyParam == undefined || param.bodyParam == ""
				? ""
				: `?${serialization(param.bodyParam)}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: STATES + url,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}

	//
	async getPlacesAddress(param = { bodyParam, authKey }) {
		let url =
			param.bodyParam == undefined || param.bodyParam == ""
				? ""
				: `?${serialization(param.bodyParam)}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: PLACES_ADDRESS + url,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async getPlacesAddressDetails(param = { bodyParam, authKey }) {
		let url =
			param.bodyParam == undefined || param.bodyParam == ""
				? ""
				: `?${serialization(param.bodyParam)}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: PLACES_ADDRESS_DETAIL + url,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}

	async searchAddress(param = { searchKey, authKey }) {
		let url = param.searchKey;
		try {
			const [error, responseJson] = await network.networkCall({
				path: SEARCHADDRESS + url,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async reverseGeoCodingAddress(param = { lat, long, authKey }) {
		let url = `/${param.lat}/${param.long}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: ADDRESS + url,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async deleteAddress(param = { id, authKey }) {
		try {
			const [error, responseJson] = await network.networkCall({
				path: ADDRESS + `/${param.id}`,
				method: Method.DELETE,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	//MARK:-  ACCOUNTS APIS  

	async getAccountsLocations(param = { bodyParam, authKey }) {
		let url =
			param.bodyParam == undefined || param.bodyParam == ""
				? ""
				: `?${serialization(param.bodyParam)}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: ACCOUNTSUNIQUELOCATIONS + url,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}

	async getAccounts(param = { bodyParam, authKey }) {
		let url = `?${serialization(param.bodyParam)}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: ACCOUNTS + `${url}`,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async getAccountDetail(param = { id, slug, authKey }) {
		var path = "";
		if (param.id != undefined) {
			if (param.id.length != 0) {
				path = `/${param.id}`;
			}
		}
		if (param.slug != undefined) {
			if (param.slug.length != 0) {
				path = SLUG + `${encodeURIComponent(param.slug)}`;
			}
		}
		try {
			const [error, responseJson] = await network.networkCall({
				path: ACCOUNTS + `${path}`,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}

	async postAccounts(param = { id, authKey, data }) {
		let method =
			param.id == undefined || param.id == ""
				? Method.POST
				: Method.PUT;
		let path =
			param.id == undefined || param.id == ""
				? ACCOUNTS
				: ACCOUNTS + `/${param.id}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: path,
				method: method,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
				param: param.data,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}

	async activeInactiveAccounts(param = { id, authKey, data }) {
		let method = Method.PATCH;
		let path = ACCOUNTS + `/${param.id}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: path,
				method: method,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
				param: param.data,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}

	async followUnfollowAccounts(
		param = { id, authKey, isFollowing: Boolean }
	) {
		let method = param.isFollowing ? Method.DELETE : Method.POST;
		let path = ACCOUNTS + `/${param.id}` + FOLLOW;
		try {
			const [error, responseJson] = await network.networkCall({
				path: path,
				method: method,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async blockAccount(param = { id, authKey, isBlocked: Boolean }) {
		let method = param.isBlocked ? Method.DELETE : Method.POST;
		let path = ACCOUNTS + `/${param.id}` + BLOCK;
		try {
			const [error, responseJson] = await network.networkCall({
				path: path,
				method: method,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async reportAccount(param = { id, authKey, data }) {
		let method = Method.POST;
		let path = ACCOUNTS + `/${param.id}` + REPORT;
		try {
			const [error, responseJson] = await network.networkCall({
				path: path,
				method: method,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
				param: param.data,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async getBlockAccounts(param = { bodyParam, authKey }) {
		let url = `${serialization(param.bodyParam)}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: BLOCKEDACCOUNT + `${url}`,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async getFollowingAccounts(param = { bodyParam, authKey }) {
		let url = `${serialization(param.bodyParam)}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: FOLLOWINGACCOUNT + `${url}`,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}

	//MARK:-  LISTINGS PRICING RULES  
	async postPricingRules(param = { listing_id, rule_id, authKey, data }) {
		let method =
			param.rule_id == undefined || param.rule_id == ""
				? Method.POST
				: Method.PATCH;
		let path =
			param.rule_id == undefined || param.rule_id == ""
				? LISTINGS + `/${param.listing_id}/price_rules`
				: LISTINGS +
				`/${param.listing_id}/price_rules/${param.rule_id}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: path,
				method: method,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
				param: param.data,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}

	async getListingsPricingRules(
		param = { bodyParam, authKey, listing_id }
	) {
		let url =
			param.bodyParam == undefined || param.bodyParam == ""
				? ""
				: `?${serialization(param.bodyParam)}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path:
					LISTINGS +
					`/${param.listing_id}/price_rules` +
					url,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async getListingSinglePricingRule(
		param = { bodyParam, authKey, listing_id, rule_id }
	) {
		let url =
			param.bodyParam == undefined || param.bodyParam == ""
				? ""
				: `?${serialization(param.bodyParam)}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path:
					LISTINGS +
					`/${param.listing_id}/price_rules/${rule_id}` +
					url,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}

	async deleteListingPricingRule(
		param = { id, authKey, listing_id, rule_id }
	) {
		try {
			const [error, responseJson] = await network.networkCall({
				path:
					LISTINGS +
					`/${param.listing_id}/price_rules/${param.rule_id}`,
				method: Method.DELETE,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}

	//MARK:-  LISTINGS API  
	async getListingsLocations(param = { bodyParam, authKey }) {
		let url =
			param.bodyParam == undefined || param.bodyParam == ""
				? ""
				: `?${serialization(param.bodyParam)}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: LISTINGSUNIQUELOCATIONS + url,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async getListings(param = { bodyParam, authKey }) {
		let url =
			param.bodyParam == undefined || param.bodyParam == ""
				? ""
				: `?${serialization(param.bodyParam)}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: LISTINGS + url,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async getListingDetail(param = { id, slug, authKey }) {
		var path = "";
		if (param.id != undefined) {
			if (param.id.length != 0) {
				path = `/${param.id}`;
			}
		}
		if (param.slug != undefined) {
			if (param.slug.length != 0) {
				path = SLUG + `${encodeURIComponent(param.slug)}`;
			}
		}
		try {
			const [error, responseJson] = await network.networkCall({
				path: LISTINGS + `${path}`,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	// async getListingSlug(param={id,slug,authKey}) {

	//   try { const [error, responseJson] = await network.networkCall({path:LISTINGS + SLUG +`/${param.id}`,method:Method.GET,authKey:param.authKey});
	//     if (error) { return error }
	//     else { return responseJson }
	//   } catch (error) { return error }
	// }
	async deleteListing(param = { id, authKey }) {
		try {
			const [error, responseJson] = await network.networkCall({
				path: LISTINGS + `/${param.id}`,
				method: Method.DELETE,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async postListing(param = { id, authKey, data }) {
		let method =
			param.id == undefined || param.id == ""
				? Method.POST
				: Method.PATCH;
		let path =
			param.id == undefined || param.id == ""
				? LISTINGS
				: LISTINGS + `/${param.id}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: path,
				method: method,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
				param: param.data,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async likeListing(param = { id, authKey, isLiked: Boolean }) {
		let method = param.isLiked ? Method.DELETE : Method.POST;
		let path = LISTINGS + `/${param.id}` + LIKE;
		try {
			const [error, responseJson] = await network.networkCall({
				path: path,
				method: method,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async unlikeListing(param = { id, authKey, isUnLiked: Boolean }) {
		let method = param.isUnLiked ? Method.DELETE : Method.POST;
		let path = LISTINGS + `/${param.id}` + UNLIKE;
		try {
			const [error, responseJson] = await network.networkCall({
				path: path,
				method: method,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}

	async bulkLikeListings(param = { data, authKey }) {
		let path = LISTINGS + `/likes/bulk`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: path,
				method: Method.POST,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
				param: param.data,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}

	async getMyListingsLikes(param = { bodyParam, authKey }) {
		let url =
			param.bodyParam == undefined || param.bodyParam == ""
				? ""
				: `?${serialization(param.bodyParam)}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: LISTINGS + LIKE + url,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async reportListing(param = { id, authKey, data }) {
		let method = Method.POST;
		let path = LISTINGS + `/${param.id}` + REPORT;
		try {
			const [error, responseJson] = await network.networkCall({
				path: path,
				method: method,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
				param: param.data,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async commonFuntion(param = { path, bodyParam, data, authKey, Method }) {
		let url =
			param.bodyParam == undefined || param.bodyParam == ""
				? ""
				: `?${serialization(param.bodyParam)}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: param.path + url,
				method: param.Method,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
				param: param.data,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async FollowingAccountsListings(param = { bodyParam, authKey }) {
		let url = `${serialization(param.bodyParam)}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: FOLLOWINGLISTING + `${url}`,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}

	//MARK:-  Negotiate 

	// POST
	async addNegotiation(param = { id, authKey, data }) {
		let method = Method.POST;
		let path = LISTINGS + `/${param.id}` + NEGOTIATE;
		try {
			const [error, responseJson] = await network.networkCall({
				path: path,
				method: method,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
				param: param.data,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}

	// PATCH
	async updateNegotiation(param = { id, authKey, data, negotiation_id }) {
		let method = Method.PATCH;
		let path =
			LISTINGS +
			`/${param.id}` +
			NEGOTIATE +
			`/${param.negotiation_id}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: path,
				method: method,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
				param: param.data,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}

	// GET
	async getNegotiationList(param = { id, authKey, bodyParam }) {
		let method = Method.GET;
		let path =
			LISTINGS +
			`/${param.id}` +
			NEGOTIATE +
			`?${serialization(param.bodyParam)}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: path,
				method: method,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	//MARK:-  Schedules 
	async createSchedule(param = { id, authKey, data }) {
		let path = LISTINGS + `/${param.id}` + SCHEDULE;
		try {
			const [error, responseJson] = await network.networkCall({
				path: path,
				method: Method.PUT,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
				param: param.data,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async getSchedule(param = { id, bodyParam, authKey }) {
		let url =
			param.bodyParam == undefined || param.bodyParam == ""
				? ""
				: `${serialization(param.bodyParam)}`;
		let path = LISTINGS + `/${param.id}` + SCHEDULEPERDAY;
		try {
			const [error, responseJson] = await network.networkCall({
				path: path + url,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	//MARK:-  Variants 
	async getVariants(param = { authKey }) {
		try {
			const [error, responseJson] = await network.networkCall({
				path: VARIANTS,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async getListingVariants(param = { authKey, listingId }) {
		try {
			const [error, responseJson] = await network.networkCall({
				path: LISTINGS + `/${param.listingId}` + VARIANTS,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async getListingVariantDetails(
		param = { authKey, listingId, variant_id }
	) {
		try {
			const [error, responseJson] = await network.networkCall({
				path:
					LISTINGS +
					`/${param.listingId}` +
					VARIANTS +
					`/${param.variant_id}`,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async addEditVariants(param = { authKey, listingId, id, data }) {
		let method =
			param.id == undefined || param.id == ""
				? Method.POST
				: Method.PUT;
		let path =
			param.id == undefined || param.id == ""
				? LISTINGS + `/${param.listingId}` + VARIANTS
				: LISTINGS +
				`/${param.listingId}` +
				VARIANTS +
				`/${param.id}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: path,
				method: method,
				param: param.data,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async deleteVariant(param = { id, listingId, authKey }) {
		let url =
			LISTINGS +
			`/${param.listingId}` +
			VARIANTS +
			`/${param.id}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: url,
				method: Method.DELETE,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	//MARK:-  Variant Types  
	async getVariantTypes(param = { authKey }) {
		try {
			const [error, responseJson] = await network.networkCall({
				path: VARIANTTYPES,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async addEditVariantsTypes(param = { authKey, id, data }) {
		let method =
			param.id == undefined || param.id == ""
				? Method.POST
				: Method.PUT;
		let path =
			param.id == undefined || param.id == ""
				? VARIANTTYPES
				: VARIANTTYPES + `/${param.id}/`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: path,
				method: method,
				param: param.data,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async deleteVariantType(param = { id, authKey }) {
		let url = VARIANTTYPES + `/${param.id}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: url,
				method: Method.DELETE,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	//MARK:-  Variant Types Values  
	async getVariantTypeValues(param = { id, authKey }) {
		let url = VARIANTTYPES + `/${param.id}` + VALUES;
		try {
			const [error, responseJson] = await network.networkCall({
				path: url,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async getVariantTypeValuesDetail(param = { id, valueID, authKey }) {
		let url =
			VARIANTTYPES +
			`/${param.id}` +
			VALUES +
			`/${param.valueID}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: url,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async addEditVariantTypeValues(param = { id, valueID, data, authKey }) {
		let path =
			param.id == undefined || param.id == ""
				? VARIANTTYPES + `/${param.id}` + VALUES
				: VARIANTTYPES +
				`/${param.id}` +
				VALUES +
				`/${param.valueID}`;
		let method =
			param.id == undefined || param.id == ""
				? Method.POST
				: Method.PUT;
		try {
			const [error, responseJson] = await network.networkCall({
				path: path,
				method: method,
				param: param.data,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async deleteVariantTypeValues(param = { id, authKey, valueID }) {
		let url =
			VARIANTTYPES +
			`/${param.id}` +
			VALUES +
			`/${param.valueID}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: url,
				method: Method.DELETE,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	//MARK:-  CATEGORY APIS  
	async getCategory(param = { bodyParam, authKey }) {
		let url =
			param.bodyParam == undefined || param.bodyParam == ""
				? ""
				: `?${serialization(param.bodyParam)}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: CATEGORY + url,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}

	async getSingleCategoryByID(param = { bodyParam, authKey, categoryID }) {
		let url =
			param.bodyParam == undefined || param.bodyParam == ""
				? ""
				: `?${serialization(param.bodyParam)}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: CATEGORY + `/${param.categoryID}` + url,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async getSingleCategoryBySlug(param = { bodyParam, authKey, slug }) {
		let url =
			param.bodyParam == undefined || param.bodyParam == ""
				? ""
				: `?${serialization(param.bodyParam)}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path:
					CATEGORY +
					`/by_slug/${encodeURIComponent(
						param.slug
					)}` +
					url,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async addEditCategory(param = { id, data, authKey }) {
		let path =
			param.id == undefined || param.id == ""
				? CATEGORY
				: CATEGORY + `/${param.id}`;
		let method =
			param.id == undefined || param.id == ""
				? Method.POST
				: Method.PUT;
		try {
			const [error, responseJson] = await network.networkCall({
				path: path,
				method: method,
				param: param.data,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async deleteCategory(param = { id, authKey }) {
		try {
			const [error, responseJson] = await network.networkCall({
				path: CATEGORY + `/${param.id}`,
				method: Method.DELETE,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	//MARK:-  Attribute APIS  

	async getAttribute(param = { bodyParam, authKey }) {
		let url =
			param.bodyParam == undefined || param.bodyParam == ""
				? ""
				: `?${serialization(param.bodyParam)}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: ATTRIBUTE + url,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async getUserAttributeValues(param = { bodyParam, authKey }) {
		let url =
			param.bodyParam == undefined || param.bodyParam == ""
				? ""
				: `?${serialization(param.bodyParam)}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path:
					ATTRIBUTE +
					`/${param.id}` +
					"/user_attributes_values" +
					url,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async getAttributesGrouped(param = { bodyParam, authKey }) {
		let url =
			param.bodyParam == undefined || param.bodyParam == ""
				? ""
				: `?${serialization(param.bodyParam)}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: ATTRIBUTE + "/grouped" + url,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async addEditAttribute(param = { id, data, authKey }) {
		let path =
			param.id == undefined || param.id == ""
				? ATTRIBUTE
				: ATTRIBUTE + `/${param.id}`;
		let method =
			param.id == undefined || param.id == ""
				? Method.POST
				: Method.PUT;
		try {
			const [error, responseJson] = await network.networkCall({
				path: path,
				method: method,
				param: param.data,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async deleteAttribute(param = { id, authKey }) {
		try {
			const [error, responseJson] = await network.networkCall({
				path: ATTRIBUTE + `/${param.id}`,
				method: Method.DELETE,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	//MARK:-  Values
	async getAttributeValues(param = { id, authKey }) {
		let url = ATTRIBUTE + `/${param.id}` + VALUES;
		try {
			const [error, responseJson] = await network.networkCall({
				path: url,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async getAttributeValuesDetail(param = { id, valueID, authKey }) {
		let url =
			ATTRIBUTE + `/${param.id}` + VALUES + `/${param.valueID}`;
		try {
			const [error, responseJson] = await network.networkCall({
				path: url,
				method: Method.GET,
				authKey: param.authKey,
				currency: param.currency,
				language: param.language,
				pkKey: param.pkKey,
				baseURL: param.baseURL,
			});
			if (error) {
				return error;
			} else {
				return responseJson;
			}
		} catch (error) {
			return error;
		}
	}
	async addEditAttributeValues(param = { id, valueID, data, authKey }