const saveAddressUsingAddressHierarchy = async (nodeValue: string, nodeType: string) => {
        if (!isKeyOfNewAddress(nodeType) || !nodeValue) return;
        setLoading(true);

        const fetchLocality = await fetchAddressUsingAddressHierarchy({ queryString: nodeValue, searchType: nodeType });

        if (!fetchLocality.isSuccess) {
            setNewAddress({
                ...newAddress,
                city: '',
                state: '',
                country: '',
            });
            setDisableLocality(false);
        } else {
            let nodeFound = false;
            const parentLevelNodes = [];
            for (let i = 0; i < hierarchyData?.length; i += 1) {
                const curNode = hierarchyData[i].location_key.toLowerCase();
                if ((nodeFound || curNode === nodeType.toLocaleLowerCase()) && curNode in fetchLocality?.data) {
                    nodeFound = true;
                    parentLevelNodes.push({ key: hierarchyData[i].location_key, value: fetchLocality?.data[curNode] });
                }
            }
            const fetchedAddressFieldsObj = parentLevelNodes?.reduce((acc, curr) => {
                if (isKeyOfNewAddress(curr.key)) {
                    acc[curr.key] = curr.value || null;
                    if (curr.key !== nodeType && (!isAddressMappingAllowed && curr.value)) {
                        setDisableLocality(true, curr.key);
                    } else {
                        setDisableLocality(false, curr.key);
                    }
                }
                return acc;
            }, {} as { [key: string]: string | null });
            setNewAddress({
                ...newAddress,
                ...fetchedAddressFieldsObj,
            });
        }

        setLoading(false);
    };

const loadPincodes = async (value: any) => {
        if (value?.length < 3) return;
        if (!hierarchyData?.some((node: any) => node.location_key === 'pincode')) return;
        setLoading(true);

        const response = await fetchPincodeList(value);
        if (response && response.isSuccess && Array.isArray(response?.data)) {
            setLocalityPincodesList(response.data || []);
        }
        setLoading(false);
    };

 useEffect(() => {
        loadPincodes(newAddress.pincode);
    }, [debouncePincode]);

//import { useDebounce } from 'hooks/use-debounce'; using already imported (was being used for w3wCode) useDebounce HoC
//SEARCH_TIMEOUT = 500 -> debounce time is used by default
const debouncePincode = useDebounce(newAddress.pincode);

    const renderPincodeBox = () => {
        if (isAddressHierarchyPresent && isAddressMappingAllowed && hierarchyFieldsArr.include('pincode')) {
            return (
                <AutoComplete
                    value={newAddress.pincode}
                    className={classes.pincodeInput}
                    dropdownClassName={classes.pincodeInputDropdown}
                    options={
                        localityPincodesList.map((pincode: any) => {
                            return {
                                label: `${pincode.name} (${pincode.code})`,
                                value: pincode.code,
                            };
                        })
                    }
                    onSearch={loadPincodes}
                    onSelect={(e) => saveAddressUsingAddressHierarchy(e, 'pincode')}
                    onChange={(value) => updateAddressFieldWithValidations('pincode', value)}
                    style={{ textAlign: 'left' }}
                    allowClear
                >
                    <Input
                        className={classes.autoCompleteInputBox}
                        allowClear
                        placeholder={t('address_pincode')}
                    />
                </AutoComplete>
            );
        }
        if (isAddressHierarchyPresent && !isAddressMappingAllowed && hierarchyFieldsArr.include('pincode')) {
            return (
                <Form.Item
                    className={classes.pincodeWithExtra}
                    name="pincode"
                    extra={samplePincode ? `Ex. ${samplePincode}` : undefined}
                >
                    <Select
                        value={newAddress.pincode}
                        dropdownClassName={classes.pincodeInputDropdown}
                        placeholder={t('address_pincode')}
                        onChange={(e) => {
                            updateAddressFieldWithValidations('pincode', e);
                            const isValid = isValidPincode(e);
                            if (isValid !== validPincode) {
                                setValidPincode(isValid);
                            }
                        }}
                        options={
                            localityPincodesList.map((pincode: any) => {
                                return {
                                    label: `${pincode.name} (${pincode.code})`,
                                    value: pincode.code,
                                };
                            })
                        }
                        onSelect={(e) => saveAddressUsingAddressHierarchy(e, 'pincode')}
                        defaultActiveFirstOption={false}
                        filterOption={false}
                        onSearch={loadPincodes}
                        showSearch
                        allowClear
                        style={validPincode ? {} : { borderColor: 'red' }}
                    />
                </Form.Item>
            );
        }
        return (
            <Input
                value={newAddress.pincode}
                className={classes.pincodeInput}
                placeholder={t('address_pincode')}
                onChange={(e) => updateAddressFieldWithValidations('pincode', e.target.value)}
            />
        );
    };

//api to fetch states list
export const FETCH_STATES_LIST = '/api/CustomerPortal/addressManagement/getAddressNodeData?type=State';
//api to fetch nodes value based on address hierarchy (new dev api)
export const FETCH_ADDRESS_FROM_ADDRESS_HIERARCHY = '/api/CustomerPortal/fetchGeneralAddressCode';

export const fetchAddressUsingAddressHierarchy = (params: any) => {
    return POST(`${API_BASE_URL}${FETCH_ADDRESS_FROM_ADDRESS_HIERARCHY}`, params);
};

//exporting functions to fetch nodes' list to be called from create-address.tsx file on entering sompething in inpit fileds (> 3chars)
export const fetchCountriesList = (params: any) => {
    return GET(`${API_BASE_URL}${FETCH_COUNTRIES_NODE_DATA}`,
        { isDataSearchApplied: true, searchQuery: params, sortResult: true });
};

export const fetchCitiesList = (params: any) => {
    return GET(`${API_BASE_URL}${FETCH_CITIES_LIST}`,
        { isDataSearchApplied: true, searchQuery: params, sortResult: true });
};


export const fetchStatesList = (params: any) => {
    return GET(`${API_BASE_URL}${FETCH_STATES_LIST}`,
        { isDataSearchApplied: true, searchQuery: params, sortResult: true });
};

export const FETCH_STATES_LIST = '/api/CustomerPortal/addressManagement/getAddressNodeData?type=State';
export const FETCH_COUNTRIES_NODE_DATA = '/api/CustomerPortal/addressManagement/getAddressNodeData?type=Country';
export const FETCH_ADDRESS_FROM_ADDRESS_HIERARCHY = '/api/CustomerPortal/fetchGeneralAddressCode';

 const saveAddressUsingAddressHierarchy = async (nodeValue, nodeType) => {
    if (!nodeType) return;

    if (!nodeValue) {
      handleAddressFields(nodeType, null, false);
      return;
    }

    const fetchLocality = await fetchAddressUsingAddressHierarchy({ queryString: nodeValue, searchType: nodeType });

    if (!fetchLocality.isSuccess) {
      form.setFieldsValue({
        cityName: '',
        stateName: '',
        countryName: '',
      });
      setDisableLocality(false, null);
    } else {
      handleAddressFields(nodeType, fetchLocality, false);
    }
  };

const debouncePincode = lodash.debounce(async (value) => {
    const pincodesListResp = await searchAddressNodeData({ type: 'pincode', isDataSearchApplied: true, searchQuery: value, sortResult: true });
    if (pincodesListResp?.isSuccess && Array.isArray(pincodesListResp?.data)) {
      setPincodesList(pincodesListResp.data || []);
    }
  }, 500);

  const loadPincodes = async (value) => {
    if (value?.length < 3) return;
    if (!hierarchyData?.some((node: any) => node.location_key === 'pincode')) return;
    debouncePincode(value);
  };

<FormItem
              {...formItemLayoutNew}
              className={classes.formCounterBooking}
              label={<div>{t("pincode")}</div>}
            >
              {!allowOverrideHierarchy && isAddressHierarchyPresent && getFieldDecorator('pincode', {
                initialValue: address['pincode'],
                rules: [
                  { required: false, message: 'Cannot be empty!' },
                ],
              })(
                <Select
                  style={{ textAlign: 'left' }}
                  showSearch
                  optionFilterProp="children"
                  onChange={(value) => saveAddressUsingAddressHierarchy(value, 'pincode')}
                  placeholder={t("pincode_placeholder")}
                  onSearch={loadPincodes}