vineanova-redux-artifacts/src/services/apiServices.js

## Overview

import serviceConfig from "./config/serviceConfig";

    export const getActivityDefaultRates = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/ActivityDefaultRates';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "get",
          params: {
            ...queryParams,
          },
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const postActivityDefaultRates = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/ActivityDefaultRates';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "post",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const putActivityDefaultRates = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/ActivityDefaultRates';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "put",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const deleteActivityDefaultRates = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/ActivityDefaultRates';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "delete",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const getBlockRowPlant = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/BlockRowPlant';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "get",
          params: {
            ...queryParams,
          },
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const postBlockRowPlant = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/BlockRowPlant';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "post",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const putBlockRowPlant = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/BlockRowPlant';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "put",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const deleteBlockRowPlant = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/BlockRowPlant';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "delete",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const getPlantsForBlock = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/PlantsForBlock';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "get",
          params: {
            ...queryParams,
          },
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const getBlockVintage = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/BlockVintage';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "get",
          params: {
            ...queryParams,
          },
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const postBlockVintage = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/BlockVintage';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "post",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const putBlockVintage = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/BlockVintage';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "put",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const deleteBlockVintage = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/BlockVintage';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "delete",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const getCharts = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/Charts';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "get",
          params: {
            ...queryParams,
          },
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const postCharts = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/Charts';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "post",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const postChartsByChartFilters = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/ChartsByChartFilters';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "post",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const postChartsByPageFilters = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/ChartsByPageFilters';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "post",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const getChartFilter = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/ChartFilter';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "get",
          params: {
            ...queryParams,
          },
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const postChartFilters = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/ChartFilters';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "post",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const getDashboardPages = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/DashboardPages';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "get",
          params: {
            ...queryParams,
          },
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const getDashboardPageFilters = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/DashboardPageFilters';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "get",
          params: {
            ...queryParams,
          },
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const postDashboardPageFilters = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/DashboardPageFilters';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "post",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const getCLearCache = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/CLearCache';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "get",
          params: {
            ...queryParams,
          },
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const getCropBlockNotes = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/CropBlockNotes';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "get",
          params: {
            ...queryParams,
          },
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const postCropBlockNotes = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/CropBlockNotes';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "post",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const putCropBlockNotes = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/CropBlockNotes';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "put",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const deleteCropBlockNotes = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/CropBlockNotes';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "delete",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const postMeasurementNoteImage = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/MeasurementNoteImage';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "post",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const getCropBlockPhenology = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/CropBlockPhenology';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "get",
          params: {
            ...queryParams,
          },
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const postCropBlockPhenology = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/CropBlockPhenology';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "post",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const putCropBlockPhenology = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/CropBlockPhenology';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "put",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const deleteCropBlockPhenology = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/CropBlockPhenology';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "delete",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const getCropBlockSetting = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/CropBlockSetting';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "get",
          params: {
            ...queryParams,
          },
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const postCropBlockSetting = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/CropBlockSetting';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "post",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const putCropBlockSetting = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/CropBlockSetting';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "put",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const deleteCropBlockSetting = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/CropBlockSetting';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "delete",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const getCropBlockVintage = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/CropBlockVintage';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "get",
          params: {
            ...queryParams,
          },
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const postCropBlockVintage = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/CropBlockVintage';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "post",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const putCropBlockVintage = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/CropBlockVintage';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "put",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const deleteCropBlockVintage = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/CropBlockVintage';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "delete",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const getSites = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/Sites';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "get",
          params: {
            ...queryParams,
          },
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const putSites = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/Sites';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "put",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const getSensors = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/Sensors';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "get",
          params: {
            ...queryParams,
          },
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const putSensors = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/Sensors';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "put",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const getSensorBlocks = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/SensorBlocks';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "get",
          params: {
            ...queryParams,
          },
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const getTriggerSensorSummaryDataSync = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/TriggerSensorSummaryDataSync';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "get",
          params: {
            ...queryParams,
          },
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const getEventLog = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/EventLog';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "get",
          params: {
            ...queryParams,
          },
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const putEventLogStatus = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/EventLogStatus';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "put",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const postNewLoginEventLog = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/NewLoginEventLog';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "post",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const getDemoExcelData = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/DemoExcelData';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "get",
          params: {
            ...queryParams,
          },
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const gethealthcheck = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/healthcheck';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "get",
          params: {
            ...queryParams,
          },
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const posthealthcheck = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/healthcheck';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "post",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const getIdentity = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/Identity';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "get",
          params: {
            ...queryParams,
          },
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const getIdentityDetails = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/IdentityDetails';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "get",
          params: {
            ...queryParams,
          },
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const postIdentityStatus = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/IdentityStatus';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "post",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const getIdentitiesByRole = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/IdentitiesByRole';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "get",
          params: {
            ...queryParams,
          },
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const getIdentitiesByClassification = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/IdentitiesByClassification';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "get",
          params: {
            ...queryParams,
          },
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const getIdentitiesByType = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/IdentitiesByType';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "get",
          params: {
            ...queryParams,
          },
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const postIdentityAccommodation = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/IdentityAccommodation';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "post",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const putIdentityAccommodation = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/IdentityAccommodation';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "put",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const getIdentityAccommodation = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/IdentityAccommodation';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "get",
          params: {
            ...queryParams,
          },
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const deleteIdentityAccommodation = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/IdentityAccommodation';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "delete",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const getIdentityActivity = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/IdentityActivity';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "get",
          params: {
            ...queryParams,
          },
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const postIdentityActivity = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/IdentityActivity';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "post",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const putIdentityActivity = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/IdentityActivity';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "put",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const deleteIdentityActivity = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/IdentityActivity';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "delete",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const getIdentityClassification = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/IdentityClassification';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "get",
          params: {
            ...queryParams,
          },
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const postIdentityClassification = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/IdentityClassification';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "post",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const putIdentityClassification = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/IdentityClassification';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "put",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const deleteIdentityClassification = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/IdentityClassification';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "delete",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const postIdentityConsumable = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/IdentityConsumable';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "post",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const putIdentityConsumable = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/IdentityConsumable';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "put",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const getIdentityConsumable = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/IdentityConsumable';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "get",
          params: {
            ...queryParams,
          },
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const deleteIdentityConsumable = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/IdentityConsumable';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "delete",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const getIdentityConsumableTransactions = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/IdentityConsumableTransactions';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "get",
          params: {
            ...queryParams,
          },
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const getIdentityContactMethod = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/IdentityContactMethod';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "get",
          params: {
            ...queryParams,
          },
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const postContactMethod = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/ContactMethod';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "post",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const putContactMethod = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/ContactMethod';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "put",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const deleteContactMethod = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/ContactMethod';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "delete",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
  
    export const getIdentityContactMethodAddress = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/IdentityContactMethodAddress';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "get",
          params: {
            ...queryParams,
          },
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const postIdentityContactMethodAddress = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/IdentityContactMethodAddress';
        const response = await serviceConfig.request({
          url: apiUrl,
          method: "post",
          params: {
            ...queryParams,
          },
          data: JSON.stringify(postBody),
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
          },
          ...options,
        });
        return response;
      } catch (err) {
        throw err;
      }
    };
   
    export const putIdentityContactMethodAddress = async (payload) => {
      try {
        const { queryParams, postBody, options } = payload || {};
        let apiUrl = '/IdentityContactMethodAddress';
        const response = await serviceConfig.request({
          url: a