z2_plus: Import QC location source

 * Tag: LA.UM.5.5.r1-01800-8x96.0

Change-Id: Ib33b01591c1743dd8b217a81a580bc3c2b13bd05

27 files changed, 34749 insertions, 0 deletions

diff --git a/gps/gnsspps/Android.mk b/gps/gnsspps/Android.mk
new file mode 100644
index 0000000..70005ff
--- /dev/null
+++ b/gps/gnsspps/Android.mk
@@ -0,0 +1,32 @@
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := libgnsspps
+
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_SHARED_LIBRARIES := \
+    libutils \
+    libcutils \
+    libgps.utils \
+    liblog
+
+LOCAL_SRC_FILES += \
+   gnsspps.c
+
+LOCAL_CFLAGS += \
+    -fno-short-enums \
+    -D_ANDROID_
+
+LOCAL_COPY_HEADERS_TO:= libgnsspps/
+
+LOCAL_COPY_HEADERS:= \
+    gnsspps.h
+
+## Includes
+LOCAL_C_INCLUDES := \
+    $(TARGET_OUT_HEADERS)/gps.utils \
+    $(TARGET_OUT_HEADERS)/libloc_pla
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/gps/gnsspps/Makefile.am b/gps/gnsspps/Makefile.am
new file mode 100644
index 0000000..728ac14
--- /dev/null
+++ b/gps/gnsspps/Makefile.am
@@ -0,0 +1,35 @@
+AM_CFLAGS = \
+     $(LOCPLA_CFLAGS) \
+     -I./
+
+ACLOCAL_AMFLAGS = -I m4
+
+libgnsspps_la_SOURCES = \
+    gnsspps.c
+
+if USE_GLIB
+libgnsspps_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@
+libgnsspps_la_LDFLAGS = -lstdc++ -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
+libgnsspps_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
+else
+libgnsspps_la_CFLAGS = $(AM_CFLAGS)
+libgnsspps_la_LDFLAGS = -lpthread -shared -version-info 1:0:0
+libgnsspps_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS)
+endif
+
+libgnsspps_la_LIBADD = -lstdc++
+
+library_include_HEADERS = \
+    gnsspps.h
+
+#Create and Install libraries
+lib_LTLIBRARIES = libgnsspps.la
+
+library_includedir = $(pkgincludedir)
+pkgconfigdir = $(libdir)/pkgconfig
+pkgconfig_DATA = gnsspps.pc
+EXTRA_DIST = $(pkgconfig_DATA)
+
+
+
+
diff --git a/gps/gnsspps/configure.ac b/gps/gnsspps/configure.ac
new file mode 100644
index 0000000..cb66fc7
--- /dev/null
+++ b/gps/gnsspps/configure.ac
@@ -0,0 +1,60 @@
+# configure.ac -- Autoconf script for gps lbs-core
+#
+# Process this file with autoconf to produce a configure script
+
+# Requires autoconf tool later than 2.61
+AC_PREREQ(2.61)
+# Initialize the gps lbs-core package version 1.0.0
+AC_INIT([gnsspps],1.0.0)
+# Does not strictly follow GNU Coding standards
+AM_INIT_AUTOMAKE([foreign])
+# Disables auto rebuilding of configure, Makefile.ins
+AM_MAINTAINER_MODE
+# Verifies the --srcdir is correct by checking for the path
+AC_CONFIG_SRCDIR([Makefile.am])
+# defines some macros variable to be included by source
+AC_CONFIG_HEADERS([config.h])
+AC_CONFIG_MACRO_DIR([m4])
+
+# Checks for programs.
+AC_PROG_LIBTOOL
+AC_PROG_CXX
+AC_PROG_CC
+AM_PROG_CC_C_O
+AC_PROG_AWK
+AC_PROG_CPP
+AC_PROG_INSTALL
+AC_PROG_LN_S
+AC_PROG_MAKE_SET
+PKG_PROG_PKG_CONFIG
+
+# Checks for libraries.
+PKG_CHECK_MODULES([LOCPLA], [loc-pla])
+AC_SUBST([LOCPLA_CFLAGS])
+AC_SUBST([LOCPLA_LIBS])
+
+AC_ARG_WITH([glib],
+      AC_HELP_STRING([--with-glib],
+         [enable glib, building HLOS systems which use glib]))
+
+if (test "x${with_glib}" = "xyes"); then
+        AC_DEFINE(ENABLE_USEGLIB, 1, [Define if HLOS systems uses glib])
+        PKG_CHECK_MODULES(GTHREAD, gthread-2.0 >= 2.16, dummy=yes,
+                                AC_MSG_ERROR(GThread >= 2.16 is required))
+        PKG_CHECK_MODULES(GLIB, glib-2.0 >= 2.16, dummy=yes,
+                                AC_MSG_ERROR(GLib >= 2.16 is required))
+        GLIB_CFLAGS="$GLIB_CFLAGS $GTHREAD_CFLAGS"
+        GLIB_LIBS="$GLIB_LIBS $GTHREAD_LIBS"
+
+        AC_SUBST(GLIB_CFLAGS)
+        AC_SUBST(GLIB_LIBS)
+fi
+
+AM_CONDITIONAL(USE_GLIB, test "x${with_glib}" = "xyes")
+
+AC_CONFIG_FILES([ \
+        Makefile \
+        gnsspps.pc
+        ])
+
+AC_OUTPUT
diff --git a/gps/gnsspps/gnsspps.c b/gps/gnsspps/gnsspps.c
new file mode 100644
index 0000000..f92a862
--- /dev/null
+++ b/gps/gnsspps/gnsspps.c
@@ -0,0 +1,194 @@
+/* Copyright (c) 2011-2015, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of The Linux Foundatoin, nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <platform_lib_log_util.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <pthread.h>
+#include <timepps.h>
+#include <linux/types.h>
+
+//DRsync kernel timestamp
+static struct timespec drsyncKernelTs = {0,0};
+//DRsync userspace timestamp
+static struct timespec drsyncUserTs = {0,0};
+//flag to stop fetching timestamp
+static int isActive = 0;
+static pps_handle handle;
+
+static pthread_mutex_t ts_lock;
+
+  /*  checks the PPS source and opens it */
+int check_device(char *path, pps_handle *handle)
+{
+     int ret;
+
+     /* Try to find the source by using the supplied "path" name */
+     ret = open(path, O_RDWR);
+     if (ret < 0)
+     {
+         LOC_LOGV("%s:%d unable to open device %s", __func__, __LINE__, path);
+         return ret;
+     }
+
+     /* Open the PPS source */
+     ret = pps_create(ret, handle);
+     if (ret < 0)
+     {
+         LOC_LOGV( "%s:%d cannot create a PPS source from device %s", __func__, __LINE__, path);
+         return -1;
+     }
+     return 0;
+}
+
+/* fetches the timestamp from the PPS source */
+int read_pps(pps_handle *handle)
+{
+    struct timespec timeout;
+    pps_info infobuf;
+    int ret;
+    // 3sec timeout
+    timeout.tv_sec = 3;
+    timeout.tv_nsec = 0;
+
+       ret = pps_fetch(*handle, PPS_TSFMT_TSPEC, &infobuf,&timeout);
+
+        if (ret < 0 && ret !=-EINTR)
+        {
+            LOC_LOGV("%s:%d pps_fetch() error %d", __func__, __LINE__,  ret);
+            return -1;
+        }
+
+        pthread_mutex_lock(&ts_lock);
+        drsyncKernelTs.tv_sec = infobuf.tv_sec;
+        drsyncKernelTs.tv_nsec = infobuf.tv_nsec;
+        ret = clock_gettime(CLOCK_BOOTTIME,&drsyncUserTs);
+        pthread_mutex_unlock(&ts_lock);
+
+        if(ret != 0)
+        {
+            LOC_LOGV("%s:%d clock_gettime() error",__func__,__LINE__);
+        }
+    return 0;
+}
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/* infinitely calls read_pps() */
+void *thread_handle(void *input)
+{
+    int ret;
+    if(input != NULL)
+    {
+        LOC_LOGV("%s:%d Thread Input is present", __func__, __LINE__);
+    }
+    while(isActive)
+    {
+        ret = read_pps(&handle);
+
+        if (ret == -1 && errno != ETIMEDOUT )
+        {
+            LOC_LOGV("%s:%d Could not fetch PPS source", __func__, __LINE__);
+        }
+    }
+    return NULL;
+}
+
+/*  opens the device and fetches from PPS source */
+int initPPS(char *devname)
+{
+    int ret,pid;
+    pthread_t thread;
+    isActive = 1;
+
+    ret = check_device(devname, &handle);
+    if (ret < 0)
+    {
+        LOC_LOGV("%s:%d Could not find PPS source", __func__, __LINE__);
+        return 0;
+    }
+
+    pthread_mutex_init(&ts_lock,NULL);
+
+    pid = pthread_create(&thread,NULL,&thread_handle,NULL);
+    if(pid != 0)
+    {
+        LOC_LOGV("%s:%d Could not create thread in InitPPS", __func__, __LINE__);
+        return 0;
+    }
+    return 1;
+}
+
+/* stops fetching and closes the device */
+void deInitPPS()
+{
+    pthread_mutex_lock(&ts_lock);
+    isActive = 0;
+    pthread_mutex_unlock(&ts_lock);
+
+    pthread_mutex_destroy(&ts_lock);
+    pps_destroy(handle);
+}
+
+/* retrieves DRsync kernel timestamp,DRsync userspace timestamp
+   and updates current timestamp */
+/* Returns:
+ *     1. @Param out DRsync kernel timestamp
+ *     2. @Param out DRsync userspace timestamp
+ *     3. @Param out current timestamp
+ */
+int getPPS(struct timespec *fineKernelTs ,struct timespec *currentTs,
+           struct timespec *fineUserTs)
+{
+    int ret;
+
+    pthread_mutex_lock(&ts_lock);
+    fineKernelTs->tv_sec = drsyncKernelTs.tv_sec;
+    fineKernelTs->tv_nsec = drsyncKernelTs.tv_nsec;
+
+    fineUserTs->tv_sec = drsyncUserTs.tv_sec;
+    fineUserTs->tv_nsec = drsyncUserTs.tv_nsec;
+
+    ret = clock_gettime(CLOCK_BOOTTIME,currentTs);
+    pthread_mutex_unlock(&ts_lock);
+    if(ret != 0)
+    {
+       LOC_LOGV("%s:%d clock_gettime() error",__func__,__LINE__);
+       return 0;
+    }
+    return 1;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/gps/gnsspps/gnsspps.h b/gps/gnsspps/gnsspps.h
new file mode 100644
index 0000000..3642f3b
--- /dev/null
+++ b/gps/gnsspps/gnsspps.h
@@ -0,0 +1,45 @@
+/* Copyright (c) 2011-2015, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of The Linux Foundatoin, nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef _GNSSPPS_H
+#define _GNSSPPS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*  opens the device and fetches from PPS source */
+int initPPS(char *devname);
+/* updates the fine time stamp */
+int getPPS(struct timespec *current_ts, struct timespec *current_boottime, struct timespec *last_boottime);
+/* stops fetching and closes the device */
+void deInitPPS();
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/gps/gnsspps/gnsspps.pc.in b/gps/gnsspps/gnsspps.pc.in
new file mode 100644
index 0000000..604eedd
--- /dev/null
+++ b/gps/gnsspps/gnsspps.pc.in
@@ -0,0 +1,10 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: gnsspps
+Description: QTI GPS drplugin-client
+Version: @VERSION
+Libs: -L${libdir} -lgnsspps
+Cflags: -I${includedir}/gnsspps
diff --git a/gps/gnsspps/timepps.h b/gps/gnsspps/timepps.h
new file mode 100644
index 0000000..fe0d8f0
--- /dev/null
+++ b/gps/gnsspps/timepps.h
@@ -0,0 +1,106 @@
+/* Copyright (c) 2011-2015, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of The Linux Foundatoin, nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <errno.h>
+#include <sys/time.h>
+#include <sys/ioctl.h>
+#include <linux/types.h>
+#include <linux/pps.h>
+
+#ifndef _TIMEPPS_H
+#define _TIMEPPS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/* time of assert event */
+typedef struct  timespec pps_info;
+/* represents pps source */
+typedef int pps_handle;
+
+ /* Open the PPS source */
+static __inline int pps_create(int source, pps_handle *handle)
+{
+   int ret;
+   struct pps_kparams dummy;
+
+   if (!handle)
+   {
+      errno = EINVAL;
+      return -1;
+   }
+   /* check if current device is valid pps */
+   ret = ioctl(source, PPS_GETPARAMS, &dummy);
+   if (ret)
+   {
+      errno = EOPNOTSUPP;
+      return -1;
+   }
+   *handle = source;
+
+   return 0;
+}
+/* close the pps source */
+static __inline int pps_destroy(pps_handle handle)
+{
+   return close(handle);
+}
+/*reads timestamp from pps device*/
+static __inline int pps_fetch(pps_handle handle, const int tsformat,
+                              pps_info *ppsinfobuf,
+                              const struct timespec *timeout)
+{
+   struct pps_fdata fdata;
+   int ret;
+
+   if (tsformat != PPS_TSFMT_TSPEC)
+   {
+      errno = EINVAL;
+      return -1;
+   }
+   if (timeout)
+   {
+      fdata.timeout.sec = timeout->tv_sec;
+      fdata.timeout.nsec = timeout->tv_nsec;
+      fdata.timeout.flags = ~PPS_TIME_INVALID;
+   }
+   else
+   {
+      fdata.timeout.flags = PPS_TIME_INVALID;
+   }
+   ret = ioctl(handle, PPS_FETCH, &fdata);
+
+   ppsinfobuf->tv_sec = fdata.info.assert_tu.sec;
+   ppsinfobuf->tv_nsec = fdata.info.assert_tu.nsec;
+
+   return ret;
+}
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/gps/izat_api/Android.mk b/gps/izat_api/Android.mk
new file mode 100644
index 0000000..06db16e
--- /dev/null
+++ b/gps/izat_api/Android.mk
@@ -0,0 +1,15 @@
+ifneq ($(BUILD_TINY_ANDROID),true)
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_COPY_HEADERS_TO:= liblocationservice/lcp/inc/
+
+LOCAL_COPY_HEADERS:= \
+    IzatRemoteApi.h \
+    izat_remote_api.h
+
+include $(BUILD_COPY_HEADERS)
+
+endif # not BUILD_TINY_ANDROID
diff --git a/gps/izat_api/IzatRemoteApi.h b/gps/izat_api/IzatRemoteApi.h
new file mode 100644
index 0000000..5cd12e3
--- /dev/null
+++ b/gps/izat_api/IzatRemoteApi.h
@@ -0,0 +1,91 @@
+/*=============================================================================
+  Copyright (c) 2016, The Linux Foundation. All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are
+  met:
+  * Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+  * Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the following
+    disclaimer in the documentation and/or other materials provided
+    with the distribution.
+  * Neither the name of The Linux Foundation nor the names of its
+    contributors may be used to endorse or promote products derived
+    from this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+  ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+  BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+  OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+  IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+  =============================================================================*/
+
+#ifndef __IZATREMOTEAPIS_H__
+#define __IZATREMOTEAPIS_H__
+
+#include <gps_extended_c.h>
+
+namespace qc_loc_fw {
+    class InPostcard;
+}
+
+namespace izat_remote_api {
+
+class IzatNotifierProxy;
+
+struct OutCard;
+
+class IzatNotifier  {
+protected:
+    IzatNotifierProxy* const mNotifierProxy;
+    IzatNotifier(const char* const tag, const OutCard* subCard);
+    virtual ~IzatNotifier();
+public:
+    virtual void handleMsg(qc_loc_fw::InPostcard * const in_card) = 0;
+};
+
+
+class LocationUpdater : public IzatNotifier {
+    static const char* const sLatTag;
+    static const char* const sLonTag;
+    static const char* const sAccuracyTag;
+    static const OutCard* sSubscriptionCard;
+protected:
+    inline LocationUpdater() : IzatNotifier(sName, sSubscriptionCard) {}
+    virtual inline ~LocationUpdater() {}
+public:
+    static const char sName[];
+    virtual void handleMsg(qc_loc_fw::InPostcard * const in_card) final;
+    virtual void locationUpdate(UlpLocation& location, GpsLocationExtended& locExtended) = 0;
+};
+
+class SstpUpdater : public IzatNotifier {
+    static const char* const sLatTag;
+    static const char* const sLonTag;
+    static const char* const sUncTag;
+    static const char* const sUncConfTag;
+
+protected:
+    inline SstpUpdater() : IzatNotifier(sName, nullptr) {}
+    virtual inline ~SstpUpdater() {}
+public:
+    static const char sName[];
+    virtual void handleMsg(qc_loc_fw::InPostcard * const in_card) final;
+    void stop();
+    virtual void errReport(const char* errStr) = 0;
+    virtual void siteUpdate(const char* name, double lat, double lon,
+                            float unc, int32_t uncConfidence) = 0;
+    virtual void mccUpdate(uint32_t mcc, const char* confidence) = 0;
+};
+
+} // izat_remote_api
+
+#endif //__IZATREMOTEAPIS_H__
+
diff --git a/gps/izat_api/izat_remote_api.h b/gps/izat_api/izat_remote_api.h
new file mode 100644
index 0000000..cbfdd60
--- /dev/null
+++ b/gps/izat_api/izat_remote_api.h
@@ -0,0 +1,105 @@
+/*=============================================================================
+  Copyright (c) 2016, The Linux Foundation. All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are
+  met:
+  * Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+  * Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the following
+    disclaimer in the documentation and/or other materials provided
+    with the distribution.
+  * Neither the name of The Linux Foundation nor the names of its
+    contributors may be used to endorse or promote products derived
+    from this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+  ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+  BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+  OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+  IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+  =============================================================================*/
+
+#ifndef __IZAT_REMOTE_APIS_H__
+#define __IZAT_REMOTE_APIS_H__
+
+#include <gps_extended_c.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void (*locationUpdateCb)(UlpLocation *location,
+                                 GpsLocationExtended *locExtended,
+                                 void* clientData);
+
+/* registers a client callback for listening to location updates
+   locationCb - location callback function pointer implemented by client
+                Can not be NULL.
+   clientData - an opaque data pointer from client. This pointer will be
+                provided back when the locationCb() callbacak is called.
+                This can be used by client to store application context
+                or statemachine etc.
+                Can be NULL.
+   return: an opaque pointer that serves as a request handle. This handle
+           is to be fed to theunregisterLocationUpdater() call.
+*/
+void* registerLocationUpdater(locationUpdateCb locationCb, void* clientData);
+
+/* unregisters the client callback
+   locationUpdaterHandle - the opaque pointer from the return of
+                           registerLocationUpdater()
+*/
+void unregisterLocationUpdater(void* locationUpdaterHandle);
+
+typedef void (*errReportCb)(const char* errStr, void* clientData);
+typedef void (*sstpSiteUpdateCb)(const char* name, double lat, double lon,
+                                 float unc, int32_t uncConfidence,
+                                 void* clientData);
+typedef void (*sstpMccUpdateCb)(uint32_t mcc, const char* confidence,
+                                void* clientData);
+/* registers a client callback for listening to SSTP updates
+   siteCb - site info callback function pointer implemented by client
+            Can not be NULL.
+   mccCb  - MCC info callback function pointer implemented by client
+            Can not be NULL.
+   errCb  - callback to receive error report in string format, in case
+            of any error that might happen, and no siteCb or mccCb can
+            be called.
+            Can be NULL.
+   clientData - an opaque data pointer from client. This pointer will be
+                provided back when the locationCb() callbacak is called.
+                This can be used by client to store application context
+                or statemachine etc.
+                Can be NULL.
+   return: an opaque pointer that serves as a request handle. This handle
+           is to be fed to theunregisterLocationUpdater() call.
+*/
+void* registerSstpUpdater(sstpSiteUpdateCb siteCb, sstpMccUpdateCb mccCb,
+                          errReportCb errCb, void* clientData);
+
+/* unregisters the client callback
+   sstpUpdaterHandle - the opaque pointer from the return of
+                           registerLocationUpdater()
+*/
+void unregisterSstpUpdater(void* sstpUpdaterHandle);
+
+/* stop the current burst of SSTP updates (until next triggering event)
+   sstpUpdaterHandle - the opaque pointer from the return of
+                           registerLocationUpdater()
+*/
+void stopSstpUpdate(void* sstpUpdaterHandle);
+
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif //__IZAT_REMOTE_APIS_H__
diff --git a/gps/loc_api/Android.mk b/gps/loc_api/Android.mk
index 8bfdd1b..0a16f68 100644
--- a/gps/loc_api/Android.mk
+++ b/gps/loc_api/Android.mk
@@ -9,5 +9,11 @@ endif #TARGET_NO_RPC
 
 GPS_DIR_LIST += $(LOCAL_PATH)/libloc_api_50001/
 
+ifneq ($(QCPATH),)
+GPS_DIR_LIST += \
+    $(LOCAL_PATH)/ds_api/ \
+    $(LOCAL_PATH)/loc_api_v02/
+endif
+
 #call the subfolders
 include $(addsuffix Android.mk, $(GPS_DIR_LIST))
diff --git a/gps/loc_api/ds_api/Android.mk b/gps/loc_api/ds_api/Android.mk
new file mode 100644
index 0000000..3bc94f2
--- /dev/null
+++ b/gps/loc_api/ds_api/Android.mk
@@ -0,0 +1,49 @@
+ifneq ($(BUILD_TINY_ANDROID),true)
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := libloc_ds_api
+
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_SHARED_LIBRARIES := \
+    libutils \
+    libcutils \
+    libqmi_cci \
+    libqmi_common_so \
+    libgps.utils \
+    libdsi_netctrl \
+    libqmiservices \
+    libloc_pla
+
+LOCAL_SRC_FILES += \
+    ds_client.c
+
+LOCAL_CFLAGS += \
+    -fno-short-enums \
+    -D_ANDROID_
+
+LOCAL_COPY_HEADERS_TO:= libloc_ds_api/
+
+LOCAL_COPY_HEADERS:= \
+    ds_client.h
+
+LOCAL_LDFLAGS += -Wl,--export-dynamic
+
+## Includes
+LOCAL_C_INCLUDES := \
+    $(TARGET_OUT_HEADERS)/libloc_eng \
+    $(TARGET_OUT_HEADERS)/qmi-framework/inc \
+    $(TARGET_OUT_HEADERS)/qmi/inc \
+    $(TARGET_OUT_HEADERS)/gps.utils \
+    $(TARGET_OUT_HEADERS)/data/inc \
+    $(TARGET_OUT_HEADERS)/libloc_pla
+
+
+LOCAL_PRELINK_MODULE := false
+
+include $(BUILD_SHARED_LIBRARY)
+
+endif # not BUILD_TINY_ANDROID
diff --git a/gps/loc_api/ds_api/ds_client.c b/gps/loc_api/ds_api/ds_client.c
new file mode 100644
index 0000000..c8250bd
--- /dev/null
+++ b/gps/loc_api/ds_api/ds_client.c
@@ -0,0 +1,834 @@
+/* Copyright (c) 2013, 2015, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of The Linux Foundation, nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#define LOG_NDEBUG 0
+#define LOG_TAG "LocSvc_ds_client"
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <wireless_data_service_v01.h>
+#include <loc_log.h>
+#include <qmi_client.h>
+#include <qmi_idl_lib.h>
+#include <qmi_cci_target_ext.h>
+#include <qmi_cci_target.h>
+#include <qmi_cci_common.h>
+#include <dsi_netctrl.h>
+#include <ds_client.h>
+#include <sys/time.h>
+#include <platform_lib_includes.h>
+
+/**
+ * @file
+ * @brief DS client API declaration.
+ *
+ * @ingroup loc_ds_api
+ */
+
+/**
+ * @addtogroup loc_ds_api DS client support for location
+ * @{
+ */
+
+//Timeout to wait for wds service notification from qmi
+#define DS_CLIENT_SERVICE_TIMEOUT (4000)
+//Max timeout for the service to come up
+#define DS_CLIENT_SERVICE_TIMEOUT_TOTAL (40000)
+//Timeout for the service to respond to sync msg
+#define DS_CLIENT_SYNC_MSG_TIMEOUT (5000)
+/*Request messages the WDS client can send to the WDS service*/
+typedef union
+{
+    /*Requests the service for a list of all profiles present*/
+    wds_get_profile_list_req_msg_v01 *p_get_profile_list_req;
+    /*Requests the service for a profile's settings*/
+    wds_get_profile_settings_req_msg_v01 *p_get_profile_settings_req;
+}ds_client_req_union_type;
+
+/*Response indications that are sent by the WDS service*/
+typedef union
+{
+    wds_get_profile_list_resp_msg_v01 *p_get_profile_list_resp;
+    wds_get_profile_settings_resp_msg_v01 *p_get_profile_setting_resp;
+}ds_client_resp_union_type;
+
+static const loc_name_val_s_type event_string_tbl[DSI_EVT_MAX] =
+{
+    NAME_VAL(DSI_EVT_INVALID),
+    NAME_VAL(DSI_EVT_NET_IS_CONN),
+    NAME_VAL(DSI_EVT_NET_NO_NET),
+    NAME_VAL(DSI_EVT_PHYSLINK_DOWN_STATE),
+    NAME_VAL(DSI_EVT_PHYSLINK_UP_STATE),
+    NAME_VAL(DSI_EVT_NET_RECONFIGURED),
+    NAME_VAL(DSI_EVT_WDS_CONNECTED)
+};
+
+typedef struct
+{
+  ds_client_event_ind_cb_type *event_cb;
+  void                        *caller_cookie;
+}ds_caller_data;
+
+typedef struct {
+    //Global dsi handle
+    dsi_hndl_t dsi_net_handle;
+    //Handle to caller's data
+    ds_caller_data caller_data;
+} ds_client_session_data;
+
+static void net_ev_cb
+(
+  dsi_hndl_t handle,
+  void* user_data,
+  dsi_net_evt_t evt,
+  dsi_evt_payload_t *payload_ptr
+)
+{
+    int i;
+    (void)handle;
+    (void)user_data;
+    (void)payload_ptr;
+    ds_caller_data *callback_data = (ds_caller_data *)user_data;
+
+    LOC_LOGD("%s:%d]: Enter. Callback data: %p\n", __func__, __LINE__, callback_data);
+    if(evt > DSI_EVT_INVALID && evt < DSI_EVT_MAX)
+    {
+        LOC_LOGE("%s:%d]: Callback received: %s",
+                 __func__, __LINE__,
+                 loc_get_name_from_val(event_string_tbl,
+                         sizeof(event_string_tbl)/sizeof(event_string_tbl[0]), evt));
+
+        switch(evt) {
+        case DSI_EVT_NET_IS_CONN:
+        case DSI_EVT_WDS_CONNECTED:
+        {
+            LOC_LOGD("%s:%d]: Emergency call started\n", __func__, __LINE__);
+            callback_data->event_cb(E_DS_CLIENT_DATA_CALL_CONNECTED,
+                                    callback_data->caller_cookie);
+            break;
+        }
+        case DSI_EVT_NET_NO_NET:
+        {
+            LOC_LOGD("%s:%d]: Emergency call stopped\n", __func__, __LINE__);
+            callback_data->event_cb(E_DS_CLIENT_DATA_CALL_DISCONNECTED,
+                                    callback_data->caller_cookie);
+            break;
+        }
+        default:
+            LOC_LOGD("%s:%d]: uninteresting event\n", __func__, __LINE__);
+        }
+    }
+    LOC_LOGD("%s:%d]:Exit\n", __func__, __LINE__);
+}
+
+/*This function is called to obtain a handle to the QMI WDS service*/
+static ds_client_status_enum_type
+ds_client_qmi_ctrl_point_init(qmi_client_type *p_wds_qmi_client)
+{
+    qmi_client_type wds_qmi_client, notifier = NULL;
+    ds_client_status_enum_type status = E_DS_CLIENT_SUCCESS;
+    qmi_service_info *p_service_info = NULL;
+    uint32_t num_services = 0, num_entries = 0;
+    qmi_client_error_type ret = QMI_NO_ERR;
+    unsigned char no_signal = 0;
+    qmi_client_os_params os_params;
+    int timeout = 0;
+
+    LOC_LOGD("%s:%d]:Enter\n", __func__, __LINE__);
+
+    //Get service object for QMI_WDS service
+    qmi_idl_service_object_type ds_client_service_object =
+        wds_get_service_object_v01();
+    if(ds_client_service_object == NULL) {
+        LOC_LOGE("%s:%d]: wds_get_service_object_v01 failed\n" ,
+                    __func__, __LINE__);
+        status  = E_DS_CLIENT_FAILURE_INTERNAL;
+        goto err;
+    }
+
+    //get service addressing information
+    ret = qmi_client_get_service_list(ds_client_service_object, NULL, NULL,
+                                      &num_services);
+    LOC_LOGD("%s:%d]: qmi_client_get_service_list() first try ret %d, "
+                   "num_services %d]\n", __func__, __LINE__, ret, num_services);
+    if(ret != QMI_NO_ERR) {
+        //Register for service notification
+        ret = qmi_client_notifier_init(ds_client_service_object, &os_params, &notifier);
+        if (ret != QMI_NO_ERR) {
+            LOC_LOGE("%s:%d]: qmi_client_notifier_init failed %d\n",
+                              __func__, __LINE__, ret);
+            status = E_DS_CLIENT_FAILURE_INTERNAL;
+            goto err;
+        }
+
+        do {
+            QMI_CCI_OS_SIGNAL_CLEAR(&os_params);
+            ret = qmi_client_get_service_list(ds_client_service_object, NULL,
+                                              NULL, &num_services);
+            if(ret != QMI_NO_ERR) {
+                QMI_CCI_OS_SIGNAL_WAIT(&os_params, DS_CLIENT_SERVICE_TIMEOUT);
+                no_signal = QMI_CCI_OS_SIGNAL_TIMED_OUT(&os_params);
+                if(!no_signal)
+                    ret = qmi_client_get_service_list(ds_client_service_object, NULL,
+                                                      NULL, &num_services);
+            }
+            timeout += DS_CLIENT_SERVICE_TIMEOUT;
+            LOC_LOGV("%s:%d]: qmi_client_get_service_list() returned ret: %d,"
+                     "no_signal: %d, total timeout: %d\n", __func__, __LINE__,
+                     ret, no_signal, timeout);
+        } while( (timeout < DS_CLIENT_SERVICE_TIMEOUT_TOTAL) &&
+                 no_signal &&
+                 (ret != QMI_NO_ERR) );
+    }
+
+    //Handle failure cases
+    if(num_services == 0 || ret != QMI_NO_ERR) {
+        if(!no_signal) {
+            LOC_LOGE("%s:%d]: qmi_client_get_service_list failed even though"
+                     "service is up!  Error: %d \n", __func__, __LINE__, ret);
+            status = E_DS_CLIENT_FAILURE_INTERNAL;
+        }
+        else {
+            LOC_LOGE("%s:%d]: qmi_client_get_service_list failed after retries"
+                     "Error: %d \n", __func__, __LINE__, ret);
+            status = E_DS_CLIENT_FAILURE_TIMEOUT;
+        }
+        goto err;
+    }
+
+    LOC_LOGD("%s:%d]: qmi_client_get_service_list succeeded\n", __func__, __LINE__);
+
+    //Success
+    p_service_info = (qmi_service_info *)malloc(num_services * sizeof(qmi_service_info));
+    if(p_service_info == NULL) {
+        LOC_LOGE("%s:%d]: could not allocate memory for serviceInfo !!\n",
+               __func__, __LINE__);
+        status = E_DS_CLIENT_FAILURE_INTERNAL;
+        goto err;
+    }
+    num_entries = num_services;
+
+    //Populate service info
+    ret = qmi_client_get_service_list(ds_client_service_object, p_service_info,
+                                     &num_entries, &num_services);
+    if(ret != QMI_NO_ERR) {
+        LOC_LOGE("%s:%d]: qmi_client_get_service_list failed. ret: %d \n",
+                 __func__, __LINE__, ret);
+        status = E_DS_CLIENT_FAILURE_INTERNAL;
+        goto err;
+    }
+
+    //Initialize wds_qmi_client
+    LOC_LOGD("%s:%d]: Initializing WDS client with qmi_client_init\n", __func__,
+             __LINE__);
+    ret = qmi_client_init(&p_service_info[0], ds_client_service_object,
+                          NULL, NULL, NULL, &wds_qmi_client);
+    if(ret != QMI_NO_ERR) {
+        LOC_LOGE("%s:%d]: qmi_client_init Error. ret: %d\n", __func__, __LINE__, ret);
+        status = E_DS_CLIENT_FAILURE_INTERNAL;
+        goto err;
+    }
+    LOC_LOGD("%s:%d]: WDS client initialized with qmi_client_init\n", __func__,
+         __LINE__);
+
+    //Store WDS QMI client handle in the parameter passed in
+    *p_wds_qmi_client = wds_qmi_client;
+
+    status = E_DS_CLIENT_SUCCESS;
+    LOC_LOGD("%s:%d]: init success\n", __func__, __LINE__);
+
+    if(notifier)
+        qmi_client_release(notifier);
+
+err:
+    if(p_service_info)
+        free(p_service_info);
+
+    LOC_LOGD("%s:%d]:Exit\n", __func__, __LINE__);
+    return status;
+}
+
+/*This function reads the error code from within the response struct*/
+static ds_client_status_enum_type ds_client_convert_qmi_response(
+    uint32_t req_id,
+    ds_client_resp_union_type *resp_union)
+{
+    ds_client_status_enum_type ret = E_DS_CLIENT_FAILURE_GENERAL;
+    LOC_LOGD("%s:%d]:Enter\n", __func__, __LINE__);
+    switch(req_id)
+    {
+    case QMI_WDS_GET_PROFILE_LIST_REQ_V01 :
+    {
+        if(resp_union->p_get_profile_list_resp->resp.error !=
+           QMI_ERR_NONE_V01) {
+            LOC_LOGE("%s:%d]: Response error: %d", __func__, __LINE__,
+                     resp_union->p_get_profile_list_resp->resp.error);
+        }
+        else
+            ret = E_DS_CLIENT_SUCCESS;
+    }
+    break;
+
+    case QMI_WDS_GET_PROFILE_SETTINGS_REQ_V01 :
+    {
+        if(resp_union->p_get_profile_setting_resp->resp.error !=
+           QMI_ERR_NONE_V01) {
+            LOC_LOGE("%s:%d]: Response error: %d", __func__, __LINE__,
+                     resp_union->p_get_profile_setting_resp->resp.error);
+        }
+        else
+            ret = E_DS_CLIENT_SUCCESS;
+    }
+    break;
+
+    default:
+        LOC_LOGE("%s:%d]: Unknown request ID\n", __func__, __LINE__);
+    }
+    LOC_LOGD("%s:%d]:Exit\n", __func__, __LINE__);
+    return ret;
+}
+
+
+static ds_client_status_enum_type ds_client_send_qmi_sync_req(
+    qmi_client_type *ds_client_handle,
+    uint32_t req_id,
+    ds_client_resp_union_type *resp_union,
+    ds_client_req_union_type *req_union)
+{
+    uint32_t req_len = 0;
+    uint32_t resp_len = 0;
+    ds_client_status_enum_type ret = E_DS_CLIENT_SUCCESS;
+    qmi_client_error_type qmi_ret = QMI_NO_ERR;
+    LOC_LOGD("%s:%d]:Enter\n", __func__, __LINE__);
+    switch(req_id)
+    {
+    case QMI_WDS_GET_PROFILE_LIST_REQ_V01 :
+    {
+        req_len = sizeof(wds_get_profile_list_req_msg_v01);
+        resp_len = sizeof(wds_get_profile_list_resp_msg_v01);
+        LOC_LOGD("%s:%d]: req_id = GET_PROFILE_LIST_REQ\n",
+                       __func__, __LINE__);
+    }
+    break;
+
+    case QMI_WDS_GET_PROFILE_SETTINGS_REQ_V01 :
+    {
+        req_len = sizeof(wds_get_profile_settings_req_msg_v01);
+        resp_len = sizeof(wds_get_profile_settings_resp_msg_v01);
+        LOC_LOGD("%s:%d]: req_id = GET_PROFILE_SETTINGS_REQ\n",
+                       __func__, __LINE__);
+    }
+    break;
+
+    default:
+        LOC_LOGE("%s:%d]: Error unknown req_id=%d\n", __func__, __LINE__,
+                       req_id);
+        ret = E_DS_CLIENT_FAILURE_INVALID_PARAMETER;
+        goto err;
+    }
+
+    LOC_LOGD("%s:%d]: req_id=%d, len = %d; resp_len= %d\n", __func__, __LINE__,
+             req_id, req_len, resp_len);
+    //Send msg through QCCI
+    qmi_ret = qmi_client_send_msg_sync(
+        *ds_client_handle,
+        req_id,
+        (void *)req_union->p_get_profile_list_req,
+        req_len,
+        (void *)resp_union->p_get_profile_list_resp,
+        resp_len,
+        DS_CLIENT_SYNC_MSG_TIMEOUT);
+    LOC_LOGD("%s:%d]: qmi_client_send_msg_sync returned: %d", __func__, __LINE__, qmi_ret);
+
+    if(qmi_ret != QMI_NO_ERR) {
+        ret = E_DS_CLIENT_FAILURE_INTERNAL;
+        goto err;
+    }
+
+    ret = ds_client_convert_qmi_response(req_id, resp_union);
+
+err:
+    LOC_LOGD("%s:%d]:Exit\n", __func__, __LINE__);
+    return ret;
+}
+
+/*This function obtains the list of supported profiles*/
+static ds_client_status_enum_type ds_client_get_profile_list(
+    qmi_client_type *ds_client_handle,
+    ds_client_resp_union_type *profile_list_resp_msg,
+    wds_profile_type_enum_v01 profile_type)
+{
+    ds_client_status_enum_type ret = E_DS_CLIENT_SUCCESS;
+    ds_client_req_union_type req_union;
+    LOC_LOGD("%s:%d]:Enter\n", __func__, __LINE__);
+
+    req_union.p_get_profile_list_req = NULL;
+    req_union.p_get_profile_list_req = (wds_get_profile_list_req_msg_v01 *)
+        calloc(1, sizeof(wds_get_profile_list_req_msg_v01));
+    if(req_union.p_get_profile_list_req == NULL) {
+        LOC_LOGE("%s:%d]: Could not allocate memory for"
+                 "wds_get_profile_list_req_msg_v01\n", __func__, __LINE__);
+        goto err;
+    }
+    //Populate required members of the request structure
+    req_union.p_get_profile_list_req->profile_type_valid = 1;
+    req_union.p_get_profile_list_req->profile_type = profile_type;
+    ret = ds_client_send_qmi_sync_req(ds_client_handle,
+                                       QMI_WDS_GET_PROFILE_LIST_REQ_V01,
+                                       profile_list_resp_msg, &req_union);
+    if(ret != E_DS_CLIENT_SUCCESS) {
+        LOC_LOGE("%s:%d]: ds_client_send_qmi_req failed. ret: %d\n",
+                 __func__, __LINE__, ret);
+        goto err;
+    }
+err:
+    LOC_LOGD("%s:%d]:Exit\n", __func__, __LINE__);
+    if(req_union.p_get_profile_list_req)
+        free(req_union.p_get_profile_list_req);
+    return ret;
+}
+
+/*This function obtains settings for the profile specified by
+ the profile_identifier*/
+static ds_client_status_enum_type ds_client_get_profile_settings(
+    qmi_client_type *ds_client_handle,
+    ds_client_resp_union_type *profile_settings_resp_msg,
+    wds_profile_identifier_type_v01 *profile_identifier)
+{
+    ds_client_status_enum_type ret = E_DS_CLIENT_SUCCESS;
+    ds_client_req_union_type req_union;
+
+    LOC_LOGD("%s:%d]:Enter\n", __func__, __LINE__);
+    //Since it's a union containing a pointer to a structure,
+    //following entities have the same address
+    //- req_union
+    //- req_union.p_get_profile_settings_req
+    //- req_union.p_get_profile_settings_req->profile
+    //so we can very well assign req_union = profile_identifier
+    req_union.p_get_profile_settings_req =
+        (wds_get_profile_settings_req_msg_v01 *)profile_identifier;
+    ret = ds_client_send_qmi_sync_req(ds_client_handle,
+                                       QMI_WDS_GET_PROFILE_SETTINGS_REQ_V01,
+                                       profile_settings_resp_msg, &req_union);
+    if(ret != E_DS_CLIENT_SUCCESS) {
+        LOC_LOGE("%s:%d]: ds_client_send_qmi_req failed. ret: %d\n",
+                 __func__, __LINE__, ret);
+        goto err;
+    }
+err:
+    LOC_LOGD("%s:%d]:Exit\n", __func__, __LINE__);
+    return ret;
+}
+
+/**
+ * @brief Starts a data call using the profile number provided
+ *
+ * The function uses parameters provided from @a ds_client_open_call_type
+ * call result.
+ *
+ * @param[in] client_handle Client handle
+ * @param[in] profile_index Profile index
+ * @param[in] pdp_type      PDP type
+ *
+ * @return Operation result
+ * @retval E_DS_CLIENT_SUCCESS    On success.
+ * @retval E_DS_CLIENT_FAILURE... On error.
+ */
+static ds_client_status_enum_type ds_client_start_call
+(
+  dsClientHandleType client_handle,
+  int profile_index,
+  int pdp_type
+)
+{
+    ds_client_status_enum_type ret = E_DS_CLIENT_FAILURE_GENERAL;
+    dsi_call_param_value_t param_info;
+    dsi_hndl_t dsi_handle;
+    ds_client_session_data *ds_global_data = (ds_client_session_data *)client_handle;
+    LOC_LOGD("%s:%d]:Enter\n", __func__, __LINE__);
+    if(ds_global_data == NULL) {
+        LOC_LOGE("%s:%d]: Null callback parameter\n", __func__, __LINE__);
+        goto err;
+    }
+    dsi_handle = ds_global_data->dsi_net_handle;
+    //Set profile index as call parameter
+    param_info.buf_val = NULL;
+    param_info.num_val = profile_index;
+    dsi_set_data_call_param(dsi_handle,
+                            DSI_CALL_INFO_UMTS_PROFILE_IDX,
+                            &param_info);
+
+    //Set IP Version as call parameter
+    param_info.buf_val = NULL;
+    param_info.num_val = pdp_type;
+    dsi_set_data_call_param(dsi_handle,
+                            DSI_CALL_INFO_IP_VERSION,
+                            &param_info);
+    LOC_LOGD("%s:%d]: Starting emergency call with profile index %d; pdp_type:%d\n",
+             __func__, __LINE__, profile_index, pdp_type);
+    if(dsi_start_data_call(dsi_handle) == DSI_SUCCESS) {
+        LOC_LOGD("%s:%d]: Sent request to start data call\n",
+                 __func__, __LINE__);
+        ret = E_DS_CLIENT_SUCCESS;
+    }
+    else {
+        LOC_LOGE("%s:%d]: Could not send req to start data call \n", __func__, __LINE__);
+        ret = E_DS_CLIENT_FAILURE_GENERAL;
+        goto err;
+    }
+
+err:
+    LOC_LOGD("%s:%d]:Exit\n", __func__, __LINE__);
+    return ret;
+
+}
+
+/**
+ * @brief Prepares for call.
+ *
+ * Obtains a handle to the dsi_netctrl layer and looks up the profile
+ * to make the call. As of now. It only searches for profiles that
+ * support emergency calls.
+ *
+ * Function to open an emergency call. Does the following things:
+ * - Obtains a handle to the WDS service
+ * - Obtains a list of profiles configured in the modem
+ * - Queries each profile and obtains settings to check if emergency calls
+ *   are supported
+ * - Returns the profile index that supports emergency calls
+ * - Returns handle to dsi_netctrl
+ *
+ * @param[out] client_handle Client handle to initialize.
+ * @param[in]  callback      Pointer to callback function table.
+ * @param[in]  cookie        Client's cookie for using with callback calls.
+ * @param[out] profile_index Pointer to profile index number.
+ * @param[out] pdp_type      Pointer to PDP type.
+ *
+ * @return Operation result
+ * @retval E_DS_CLIENT_SUCCESS    On success. Output parameters are initialized.
+ * @retval E_DS_CLIENT_FAILURE... On error.
+ */
+static  ds_client_status_enum_type ds_client_open_call
+(
+  dsClientHandleType *client_handle,
+  const ds_client_cb_data *callback,
+  void *cookie,
+  int *profile_index,
+  int *pdp_type
+)
+{
+    ds_client_status_enum_type ret = E_DS_CLIENT_FAILURE_GENERAL;
+    ds_client_resp_union_type profile_list_resp_msg;
+    ds_client_resp_union_type profile_settings_resp_msg;
+    wds_profile_identifier_type_v01 profile_identifier;
+    uint32_t i=0;
+    dsi_hndl_t dsi_handle;
+    ds_client_session_data **ds_global_data = (ds_client_session_data **)client_handle;
+    unsigned char call_profile_index_found = 0;
+    uint32_t emergency_profile_index=0;
+    qmi_client_type wds_qmi_client;
+
+    profile_list_resp_msg.p_get_profile_list_resp = NULL;
+    profile_settings_resp_msg.p_get_profile_setting_resp = NULL;
+
+    LOC_LOGD("%s:%d]:Enter\n", __func__, __LINE__);
+    if(callback == NULL || ds_global_data == NULL) {
+        LOC_LOGE("%s:%d]: Null callback parameter\n", __func__, __LINE__);
+        goto err;
+    }
+
+    ret = ds_client_qmi_ctrl_point_init(&wds_qmi_client);
+    if(ret != E_DS_CLIENT_SUCCESS) {
+        LOC_LOGE("%s:%d]: ds_client_qmi_ctrl_point_init failed. ret: %d\n",
+                 __func__, __LINE__, ret);
+        goto err;
+    }
+
+    //Allocate memory for the response msg to obtain a list of profiles
+    profile_list_resp_msg.p_get_profile_list_resp = (wds_get_profile_list_resp_msg_v01 *)
+        calloc(1, sizeof(wds_get_profile_list_resp_msg_v01));
+    if(profile_list_resp_msg.p_get_profile_list_resp == NULL) {
+        LOC_LOGE("%s:%d]: Could not allocate memory for"
+                 "p_get_profile_list_resp\n", __func__, __LINE__);
+        ret = E_DS_CLIENT_FAILURE_NOT_ENOUGH_MEMORY;
+        goto err;
+    }
+
+    LOC_LOGD("%s:%d]: Getting profile list\n", __func__, __LINE__);
+    ret = ds_client_get_profile_list(&wds_qmi_client,
+                                      &profile_list_resp_msg,
+                                      WDS_PROFILE_TYPE_3GPP_V01);
+    if(ret != E_DS_CLIENT_SUCCESS) {
+        LOC_LOGE("%s:%d]: ds_client_get_profile_list failed. ret: %d\n",
+                 __func__, __LINE__, ret);
+        goto err;
+    }
+    LOC_LOGD("%s:%d]: Got profile list; length = %d\n", __func__, __LINE__,
+             profile_list_resp_msg.p_get_profile_list_resp->profile_list_len);
+
+    //Allocate memory for the response msg to obtain profile settings
+    //We allocate memory for only one response msg and keep re-using it
+    profile_settings_resp_msg.p_get_profile_setting_resp =
+        (wds_get_profile_settings_resp_msg_v01 *)
+        calloc(1, sizeof(wds_get_profile_settings_resp_msg_v01));
+    if(profile_settings_resp_msg.p_get_profile_setting_resp == NULL) {
+        LOC_LOGE("%s:%d]: Could not allocate memory for"
+                 "p_get_profile_setting_resp\n", __func__, __LINE__);
+        ret = E_DS_CLIENT_FAILURE_NOT_ENOUGH_MEMORY;
+        goto err;
+    }
+
+    //Loop over the list of profiles to find a profile that supports
+    //emergency calls
+    for(i=0; i < profile_list_resp_msg.p_get_profile_list_resp->profile_list_len; i++) {
+        /*QMI_WDS_GET_PROFILE_SETTINGS_REQ requires an input data
+          structure that is of type wds_profile_identifier_type_v01
+          We have to fill that structure for each profile from the
+          info obtained from the profile list*/
+        //copy profile type
+        profile_identifier.profile_type =
+            profile_list_resp_msg.p_get_profile_list_resp->profile_list[i].profile_type;
+        //copy profile index
+        profile_identifier.profile_index =
+            profile_list_resp_msg.p_get_profile_list_resp->profile_list[i].profile_index;
+
+        ret = ds_client_get_profile_settings(&wds_qmi_client,
+                                             &profile_settings_resp_msg,
+                                             &profile_identifier);
+        if(ret != E_DS_CLIENT_SUCCESS) {
+            LOC_LOGE("%s:%d]: ds_client_get_profile_settings failed. ret: %d\n",
+                     __func__, __LINE__, ret);
+            goto err;
+        }
+        LOC_LOGD("%s:%d]: Got profile setting for profile %d; name: %s\n",
+                 __func__, __LINE__, i,
+                 profile_settings_resp_msg.p_get_profile_setting_resp->profile_name);
+
+        if(profile_settings_resp_msg.p_get_profile_setting_resp->support_emergency_calls_valid) {
+            if(profile_settings_resp_msg.p_get_profile_setting_resp->support_emergency_calls) {
+                LOC_LOGD("%s:%d]: Found emergency profile in profile %d"
+                         , __func__, __LINE__, i);
+                call_profile_index_found = 1;
+                emergency_profile_index = profile_identifier.profile_index;
+
+                if(profile_settings_resp_msg.p_get_profile_setting_resp->pdp_type_valid) {
+                    *pdp_type = (int)profile_settings_resp_msg.p_get_profile_setting_resp->pdp_type;
+                    LOC_LOGD("%s:%d]: pdp_type: %d\n", __func__, __LINE__, *pdp_type);
+                    switch(*pdp_type) {
+                    case WDS_PDP_TYPE_PDP_IPV4_V01:
+                        *pdp_type = DSI_IP_VERSION_4;
+                        break;
+                    case WDS_PDP_TYPE_PDP_IPV6_V01:
+                        *pdp_type = DSI_IP_VERSION_6;
+                        break;
+                    case WDS_PDP_TYPE_PDP_IPV4V6_V01:
+                        *pdp_type = DSI_IP_VERSION_4_6;
+                        break;
+                    default:
+                        LOC_LOGE("%s:%d]: pdp_type unknown. Setting default as ipv4/v6\n",
+                                 __func__, __LINE__);
+                        *pdp_type = DSI_IP_VERSION_4;
+
+                    }
+                }
+                else {
+                    LOC_LOGD("%s:%d]: pdp type not valid in profile setting. Default ipv4\n",
+                             __func__, __LINE__);
+                    *pdp_type = DSI_IP_VERSION_4;
+                }
+                //Break out of for loop since we found the emergency profile
+                break;
+            }
+            else
+                LOC_LOGE("%s:%d]: Emergency profile valid but not supported in profile: %d "
+                         , __func__, __LINE__, i);
+        }
+        //Since this struct is loaded with settings for the next profile,
+        //it is important to clear out the memory to avoid values/flags
+        //from being carried over
+        memset((void *)profile_settings_resp_msg.p_get_profile_setting_resp,
+               0, sizeof(wds_get_profile_settings_resp_msg_v01));
+    }
+
+    //Release qmi client handle
+    if(qmi_client_release(wds_qmi_client) != QMI_NO_ERR) {
+        LOC_LOGE("%s:%d]: Could not release qmi client handle\n",
+                 __func__, __LINE__);
+        ret = E_DS_CLIENT_FAILURE_GENERAL;
+    }
+
+    if(call_profile_index_found) {
+        *profile_index = emergency_profile_index;
+        *ds_global_data = (ds_client_session_data *)calloc(1, sizeof(ds_client_session_data));
+        if(*ds_global_data == NULL) {
+            LOC_LOGE("%s:%d]: Could not allocate memory for ds_global_data. Failing\n",
+                     __func__, __LINE__);
+            ret = E_DS_CLIENT_FAILURE_NOT_ENOUGH_MEMORY;
+            goto err;
+        }
+
+        (*ds_global_data)->caller_data.event_cb = callback->event_cb;
+        (*ds_global_data)->caller_data.caller_cookie = cookie;
+        dsi_handle = dsi_get_data_srvc_hndl(net_ev_cb, &(*ds_global_data)->caller_data);
+        if(dsi_handle == NULL) {
+            LOC_LOGE("%s:%d]: Could not get data handle. Retry Later\n",
+                     __func__, __LINE__);
+            ret = E_DS_CLIENT_RETRY_LATER;
+            goto err;
+        }
+        else
+            (*ds_global_data)->dsi_net_handle = dsi_handle;
+    }
+    else {
+        LOC_LOGE("%s:%d]: Could not find a profile that supports emergency calls",
+                 __func__, __LINE__);
+        ret = E_DS_CLIENT_FAILURE_GENERAL;
+    }
+err:
+    if(profile_list_resp_msg.p_get_profile_list_resp)
+        free(profile_list_resp_msg.p_get_profile_list_resp);
+    if(profile_settings_resp_msg.p_get_profile_setting_resp)
+        free(profile_settings_resp_msg.p_get_profile_setting_resp);
+    LOC_LOGD("%s:%d]:Exit\n", __func__, __LINE__);
+    return ret;
+}
+
+/**
+ * @brief Stops a data call associated with the handle
+ *
+ * @param[in] client_handle Client handle
+ *
+ * @return Operation result
+ * @retval E_DS_CLIENT_SUCCESS    On success.
+ * @retval E_DS_CLIENT_FAILURE... On error.
+ */
+static ds_client_status_enum_type ds_client_stop_call(dsClientHandleType client_handle)
+{
+    ds_client_status_enum_type ret = E_DS_CLIENT_SUCCESS;
+    ds_client_session_data *p_ds_global_data = (ds_client_session_data *)client_handle;
+    LOC_LOGD("%s:%d]:Enter\n", __func__, __LINE__);
+
+    if(client_handle == NULL) {
+        LOC_LOGE("%s:%d]: Null argument received. Failing\n", __func__, __LINE__);
+        ret = E_DS_CLIENT_FAILURE_GENERAL;
+        goto err;
+    }
+
+    if(dsi_stop_data_call(p_ds_global_data->dsi_net_handle) == DSI_SUCCESS) {
+        LOC_LOGD("%s:%d]: Sent request to stop data call\n", __func__, __LINE__);
+    }
+    else {
+        LOC_LOGE("%s:%d]: Could not send request to stop data call\n",
+                 __func__, __LINE__);
+        ret = E_DS_CLIENT_FAILURE_GENERAL;
+        goto err;
+    }
+
+err:
+    LOC_LOGD("%s:%d]:Exit\n", __func__, __LINE__);
+    return ret;
+}
+
+/**
+ * @brief Releases the handle used for making data calls
+ *
+ * @param[in,out] client_handle Client handle pointer
+ *
+ * @return None
+ */
+static void ds_client_close_call(dsClientHandleType *client_handle)
+{
+    ds_client_session_data **ds_global_data = (ds_client_session_data **)client_handle;
+    LOC_LOGD("%s:%d]:Enter\n", __func__, __LINE__);
+    if(client_handle == NULL || *client_handle == NULL) {
+        LOC_LOGE("%s:%d]: Null argument received. Failing\n", __func__, __LINE__);
+        goto err;
+    }
+    dsi_rel_data_srvc_hndl((*ds_global_data)->dsi_net_handle);
+    (*ds_global_data)->dsi_net_handle = NULL;
+    free(*ds_global_data);
+    *ds_global_data = NULL;
+    LOC_LOGD("%s:%d]: Released Data handle\n", __func__, __LINE__);
+err:
+    LOC_LOGD("%s:%d]:Exit\n", __func__, __LINE__);
+    return;
+}
+
+/**
+ * @brief Initialize the DS client service
+ *
+ * This function is to be called as a first step by each process that
+ * needs to use data services. This call internally calls dsi_init()
+ * and prepares the module for making data calls.
+ * Needs to be called once for every process
+ *
+ * @return Operation result
+ * @retval E_DS_CLIENT_SUCCESS    On success.
+ * @retval E_DS_CLIENT_FAILURE... On error.
+ */
+static ds_client_status_enum_type ds_client_init()
+{
+  ds_client_status_enum_type ret = E_DS_CLIENT_SUCCESS;
+  LOC_LOGD("%s:%d]:Enter", __func__, __LINE__);
+  if(DSI_SUCCESS != dsi_init(DSI_MODE_GENERAL))
+  {
+    LOC_LOGE("%s:%d]:dsi_init failed", __func__, __LINE__);
+    ret = E_DS_CLIENT_FAILURE_GENERAL;
+  }
+  LOC_LOGD("%s:%d]:Exit", __func__, __LINE__);
+  return ret;
+}
+
+/**
+ * @brief DS client function interface table definition.
+ */
+static const ds_client_iface_type iface =
+{
+  .pfn_init       = ds_client_init,
+  .pfn_open_call  = ds_client_open_call,
+  .pfn_start_call = ds_client_start_call,
+  .pfn_stop_call  = ds_client_stop_call,
+  .pfn_close_call = ds_client_close_call
+};
+
+/**
+ * @brief Function for accessing DS client functional interface
+ *
+ * @return Pointer to interface structure.
+ */
+const ds_client_iface_type *ds_client_get_interface()
+{
+  return &iface;
+}
+
+/**
+ * @}
+ */
diff --git a/gps/loc_api/ds_api/ds_client.h b/gps/loc_api/ds_api/ds_client.h
new file mode 100644
index 0000000..ae97077
--- /dev/null
+++ b/gps/loc_api/ds_api/ds_client.h
@@ -0,0 +1,279 @@
+/* Copyright (c) 2013, 2015 The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of The Linux Foundation, nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _DS_CLIENT_H_
+#define _DS_CLIENT_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @file
+ * @brief DS client API declaration.
+ *
+ * @ingroup loc_ds_api
+ */
+
+/**
+ * @addtogroup loc_ds_api DS client support for location
+ * @{
+ */
+
+/**
+ * @brief Function name for DS client interface query.
+ *
+ * @sa ds_client_get_interface
+ */
+#define DS_CLIENT_GET_INTERFACE_FN "ds_client_get_interface"
+/**
+ * @brief Library name for loading DS client
+ */
+#ifdef USE_GLIB
+#define DS_CLIENT_LIB_NAME "libloc_ds_api.so.1"
+#else
+#define DS_CLIENT_LIB_NAME "libloc_ds_api.so"
+#endif
+
+typedef void* dsClientHandleType;
+
+typedef enum
+{
+  E_DS_CLIENT_SUCCESS                              = 0,
+  /**< Request was successful. */
+
+  E_DS_CLIENT_FAILURE_GENERAL                      = 1,
+  /**< Failed because of a general failure. */
+
+  E_DS_CLIENT_FAILURE_UNSUPPORTED                  = 2,
+  /**< Failed because the service does not support the command. */
+
+  E_DS_CLIENT_FAILURE_INVALID_PARAMETER            = 3,
+  /**< Failed because the request contained invalid parameters. */
+
+  E_DS_CLIENT_FAILURE_ENGINE_BUSY                  = 4,
+  /**< Failed because the engine is busy. */
+
+  E_DS_CLIENT_FAILURE_PHONE_OFFLINE                = 5,
+  /**< Failed because the phone is offline. */
+
+  E_DS_CLIENT_FAILURE_TIMEOUT                      = 6,
+  /**< Failed because of a timeout. */
+
+  E_DS_CLIENT_FAILURE_SERVICE_NOT_PRESENT          = 7,
+  /**< Failed because the service is not present. */
+
+  E_DS_CLIENT_FAILURE_SERVICE_VERSION_UNSUPPORTED  = 8,
+  /**< Failed because the service version is unsupported. */
+
+  E_DS_CLIENT_FAILURE_CLIENT_VERSION_UNSUPPORTED  =  9,
+  /**< Failed because the service does not support client version. */
+
+  E_DS_CLIENT_FAILURE_INVALID_HANDLE               = 10,
+  /**< Failed because an invalid handle was specified. */
+
+  E_DS_CLIENT_FAILURE_INTERNAL                     = 11,
+  /**< Failed because of an internal error in the service. */
+
+  E_DS_CLIENT_FAILURE_NOT_INITIALIZED              = 12,
+  /**< Failed because the service has not been initialized. */
+
+  E_DS_CLIENT_FAILURE_NOT_ENOUGH_MEMORY             = 13,
+  /**< Failed because not rnough memory to do the operation.*/
+
+  E_DS_CLIENT_SERVICE_ALREADY_STARTED               = 14,
+  /*Service is already started*/
+
+  E_DS_CLIENT_DATA_CALL_CONNECTED                   = 15,
+
+  E_DS_CLIENT_DATA_CALL_DISCONNECTED                = 16,
+
+  E_DS_CLIENT_RETRY_LATER                           = 17
+} ds_client_status_enum_type;
+
+/**
+ * @brief Callback function interface for handling DS service indications
+ *
+ * @param[in] result Operation result (error code).
+ * @param[in] cookie Client cookie provided when call is opened.
+ *
+ * @sa ds_client_cb_data
+ */
+typedef void ds_client_event_ind_cb_type
+(
+  ds_client_status_enum_type result,
+  void* loc_adapter_cookie
+);
+
+/**
+ * @brief Client callback function table
+ *
+ * This structure contains callback functions provided by client of DS client
+ * API for delivering event notifications.
+ *
+ * @sa ds_client_open_call_type
+ */
+typedef struct {
+  ds_client_event_ind_cb_type *event_cb;
+} ds_client_cb_data;
+
+/**
+ * @brief Initialize the DS client service
+ *
+ * This function is to be called as a first step by each process that
+ * needs to use data services. This call internally calls dsi_init()
+ * and prepares the module for making data calls.
+ * Needs to be called once for every process
+ *
+ * @return Operation result
+ * @retval E_DS_CLIENT_SUCCESS    On success.
+ * @retval E_DS_CLIENT_FAILURE... On error.
+ */
+typedef ds_client_status_enum_type ds_client_init_type();
+
+/**
+ * @brief Prepares for call.
+ *
+ * Obtains a handle to the dsi_netctrl layer and looks up the profile
+ * to make the call. As of now. It only searches for profiles that
+ * support emergency calls.
+ *
+ * Function to open an emergency call. Does the following things:
+ * - Obtains a handle to the WDS service
+ * - Obtains a list of profiles configured in the modem
+ * - Queries each profile and obtains settings to check if emergency calls
+ *   are supported
+ * - Returns the profile index that supports emergency calls
+ * - Returns handle to dsi_netctrl
+ *
+ * @param[out] client_handle Client handle to initialize.
+ * @param[in]  callback      Pointer to callback function table.
+ * @param[in]  cookie        Client's cookie for using with callback calls.
+ * @param[out] profile_index Pointer to profile index number.
+ * @param[out] pdp_type      Pointer to PDP type.
+ *
+ * @return Operation result
+ * @retval E_DS_CLIENT_SUCCESS    On success. Output parameters are initialized.
+ * @retval E_DS_CLIENT_FAILURE... On error.
+ */
+typedef ds_client_status_enum_type ds_client_open_call_type
+(
+  dsClientHandleType *client_handle,
+  const ds_client_cb_data *callback,
+  void *cookie,
+  int *profile_index,
+  int *pdp_type
+);
+
+/**
+ * @brief Starts a data call using the profile number provided
+ *
+ * The function uses parameters provided from @a ds_client_open_call_type
+ * call result.
+ *
+ * @param[in] client_handle Client handle
+ * @param[in] profile_index Profile index
+ * @param[in] pdp_type      PDP type
+ *
+ * @return Operation result
+ * @retval E_DS_CLIENT_SUCCESS    On success.
+ * @retval E_DS_CLIENT_FAILURE... On error.
+ */
+typedef ds_client_status_enum_type ds_client_start_call_type
+(
+  dsClientHandleType client_handle,
+  int profile_index,
+  int pdp_type
+);
+
+/**
+ * @brief Stops a data call associated with the handle
+ *
+ * @param[in] client_handle Client handle
+ *
+ * @return Operation result
+ * @retval E_DS_CLIENT_SUCCESS    On success.
+ * @retval E_DS_CLIENT_FAILURE... On error.
+ */
+typedef ds_client_status_enum_type ds_client_stop_call_type
+(
+  dsClientHandleType client_handle
+);
+
+/**
+ * @brief Releases the handle used for making data calls
+ *
+ * @param[in,out] client_handle Client handle pointer
+ *
+ * @return None
+ */
+typedef void ds_client_close_call_type
+(
+  dsClientHandleType *client_handle
+);
+
+/**
+ * @brief DS client functional interface table
+ *
+ * This table contains all supported DS client operations. If the operation
+ * is not supported, the corresponding entry is NULL.
+ *
+ * @sa ds_client_get_interface
+ */
+typedef struct
+{
+  ds_client_init_type       *pfn_init;
+  ds_client_open_call_type  *pfn_open_call;
+  ds_client_start_call_type *pfn_start_call;
+  ds_client_stop_call_type  *pfn_stop_call;
+  ds_client_close_call_type *pfn_close_call;
+} ds_client_iface_type;
+
+/**
+ * @brief Function for accessing DS client functional interface
+ *
+ * @return Pointer to interface structure.
+ */
+typedef const ds_client_iface_type *ds_client_get_iface_fn();
+
+/**
+ * @brief Function for accessing DS client functional interface
+ *
+ * @return Pointer to interface structure.
+ */
+ds_client_get_iface_fn ds_client_get_interface;
+
+#ifdef __cplusplus
+}
+#endif
+
+/**
+ * @}
+ */
+
+#endif /* _DS_CLIENT_H_ */
diff --git a/gps/loc_api/loc_api_v02/Android.mk b/gps/loc_api/loc_api_v02/Android.mk
new file mode 100644
index 0000000..bbdc3ba
--- /dev/null
+++ b/gps/loc_api/loc_api_v02/Android.mk
@@ -0,0 +1,60 @@
+ifneq ($(BUILD_TINY_ANDROID),true)
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := libloc_api_v02
+
+LOCAL_MODULE_TAGS := optional
+
+ifeq ($(BOARD_VENDOR_QCOM_LOC_PDK_FEATURE_SET),true)
+LOCAL_CFLAGS += -DPDK_FEATURE_SET
+endif
+
+LOCAL_SHARED_LIBRARIES := \
+    libutils \
+    libcutils \
+    libqmi_cci \
+    libqmi_common_so \
+    libloc_core \
+    libgps.utils \
+    libdl \
+    libloc_pla
+
+LOCAL_SRC_FILES = \
+    LocApiV02.cpp \
+    loc_api_v02_log.c \
+    loc_api_v02_client.c \
+    loc_api_sync_req.c \
+    location_service_v02.c
+
+LOCAL_CFLAGS += \
+    -fno-short-enums \
+    -D_ANDROID_
+
+LOCAL_COPY_HEADERS_TO:= libloc_api_v02/
+
+LOCAL_COPY_HEADERS:= \
+    location_service_v02.h \
+    loc_api_v02_log.h \
+    loc_api_v02_client.h \
+    loc_api_sync_req.h \
+    LocApiV02.h \
+    loc_util_log.h
+
+
+## Includes
+LOCAL_C_INCLUDES := \
+    $(TARGET_OUT_HEADERS)/libloc_core \
+    $(TARGET_OUT_HEADERS)/qmi-framework/inc \
+    $(TARGET_OUT_HEADERS)/qmi/inc \
+    $(TARGET_OUT_HEADERS)/gps.utils \
+    $(TARGET_OUT_HEADERS)/libloc_ds_api \
+    $(TARGET_OUT_HEADERS)/libloc_pla
+
+LOCAL_PRELINK_MODULE := false
+
+include $(BUILD_SHARED_LIBRARY)
+
+endif # not BUILD_TINY_ANDROID
diff --git a/gps/loc_api/loc_api_v02/LocApiV02.cpp b/gps/loc_api/loc_api_v02/LocApiV02.cpp
new file mode 100644
index 0000000..70a29a8
--- /dev/null
+++ b/gps/loc_api/loc_api_v02/LocApiV02.cpp
@@ -0,0 +1,4455 @@
+/* Copyright (c) 2011-2016, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of The Linux Foundatoin, nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#define LOG_NDEBUG 0
+#define LOG_TAG "LocSvc_ApiV02"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <dlfcn.h>
+
+#include <hardware/gps.h>
+
+#include <LocApiV02.h>
+#include <loc_api_v02_log.h>
+#include <loc_api_sync_req.h>
+#include <loc_api_v02_client.h>
+#include <loc_util_log.h>
+#include <gps_extended.h>
+#include "platform_lib_includes.h"
+#include <loc_cfg.h>
+
+using namespace loc_core;
+
+/* Doppler Conversion from M/S to NS/S */
+#define MPS_TO_NSPS         (1.0/0.299792458)
+
+/* Default session id ; TBD needs incrementing for each */
+#define LOC_API_V02_DEF_SESSION_ID (1)
+
+/* UMTS CP Address key*/
+#define LOC_NI_NOTIF_KEY_ADDRESS           "Address"
+
+/* GPS SV Id offset */
+#define GPS_SV_ID_OFFSET        (1)
+
+/* GLONASS SV Id offset */
+#define GLONASS_SV_ID_OFFSET    (65)
+
+/* SV ID range */
+#define SV_ID_RANGE             (32)
+
+#define BDS_SV_ID_OFFSET         (201)
+
+/* BeiDou SV ID RANGE*/
+#define BDS_SV_ID_RANGE          QMI_LOC_DELETE_MAX_BDS_SV_INFO_LENGTH_V02
+
+/* GPS week unknown*/
+#define C_GPS_WEEK_UNKNOWN      (65535)
+
+/* seconds per week*/
+#define WEEK_MSECS              (60*60*24*7*1000)
+
+/* number of QMI_LOC messages that need to be checked*/
+#define NUMBER_OF_MSG_TO_BE_CHECKED        (3)
+
+/* Gaussian 2D scaling table - scale from x% to 68% confidence */
+struct conf_scaler_to_68_pair {
+    uint8_t confidence;
+    float scaler_to_68;
+};
+/* length of confScalers array */
+#define CONF_SCALER_ARRAY_MAX   (3)
+const struct conf_scaler_to_68_pair confScalers[CONF_SCALER_ARRAY_MAX] = {
+    {39, 1.517}, // 0 - 39 . Index 0
+    {50, 1.287}, // 40 - 50. Index 1
+    {63, 1.072}, // 51 - 63. Index 2
+};
+
+#define GPS_CONF_FILE "/etc/gps.conf"
+
+/*fixed timestamp uncertainty 10 milli second */
+static int ap_timestamp_uncertainty = 0;
+static loc_param_s_type gps_conf_param_table[] =
+{
+        {"AP_TIMESTAMP_UNCERTAINTY",&ap_timestamp_uncertainty,NULL,'n'}
+};
+
+/* static event callbacks that call the LocApiV02 callbacks*/
+
+/* global event callback, call the eventCb function in loc api adapter v02
+   instance */
+static void globalEventCb(locClientHandleType clientHandle,
+                          uint32_t eventId,
+                          const locClientEventIndUnionType eventPayload,
+                          void*  pClientCookie)
+{
+  MODEM_LOG_CALLFLOW(%s, loc_get_v02_event_name(eventId));
+  LocApiV02 *locApiV02Instance =
+      (LocApiV02 *)pClientCookie;
+
+  LOC_LOGV ("%s:%d] client = %p, event id = %d, client cookie ptr = %p\n",
+                  __func__,  __LINE__,  clientHandle, eventId, pClientCookie);
+
+  // return if null is passed
+  if( NULL == locApiV02Instance)
+  {
+    LOC_LOGE ("%s:%d] NULL object passed : client = %p, event id = %d\n",
+                  __func__,  __LINE__,  clientHandle, eventId);
+    return;
+  }
+  locApiV02Instance->eventCb(clientHandle, eventId, eventPayload);
+}
+
+/* global response callback, it calls the sync request process
+   indication function to unblock the request that is waiting on this
+   response indication*/
+static void globalRespCb(locClientHandleType clientHandle,
+                         uint32_t respId,
+                         const locClientRespIndUnionType respPayload,
+                         uint32_t respPayloadSize,
+                         void*  pClientCookie)
+{
+  MODEM_LOG_CALLFLOW(%s, loc_get_v02_event_name(respId));
+  LocApiV02 *locApiV02Instance =
+        (LocApiV02 *)pClientCookie;
+
+  LOC_LOGV ("%s:%d] client = %p, resp id = %d, client cookie ptr = %p\n",
+                  __func__,  __LINE__,  clientHandle, respId, pClientCookie);
+
+  if( NULL == locApiV02Instance)
+  {
+    LOC_LOGE ("%s:%d] NULL object passed : client = %p, resp id = %d\n",
+                  __func__,  __LINE__,  clientHandle, respId);
+    return;
+  }
+
+  // process the sync call
+  // use pDeleteAssistDataInd as a dummy pointer
+  loc_sync_process_ind(clientHandle, respId,
+          (void *)respPayload.pDeleteAssistDataInd, respPayloadSize);
+}
+
+/* global error callback, it will call the handle service down
+   function in the loc api adapter instance. */
+static void globalErrorCb (locClientHandleType clientHandle,
+                           locClientErrorEnumType errorId,
+                           void *pClientCookie)
+{
+  LocApiV02 *locApiV02Instance =
+          (LocApiV02 *)pClientCookie;
+
+  LOC_LOGV ("%s:%d] client = %p, error id = %d\n, client cookie ptr = %p\n",
+                  __func__,  __LINE__,  clientHandle, errorId, pClientCookie);
+  if( NULL == locApiV02Instance)
+  {
+    LOC_LOGE ("%s:%d] NULL object passed : client = %p, error id = %d\n",
+                  __func__,  __LINE__,  clientHandle, errorId);
+    return;
+  }
+  locApiV02Instance->errorCb(clientHandle, errorId);
+}
+
+/* global structure containing the callbacks */
+locClientCallbacksType globalCallbacks =
+{
+    sizeof(locClientCallbacksType),
+    globalEventCb,
+    globalRespCb,
+    globalErrorCb
+};
+
+static void getInterSystemTimeBias(const char* interSystem,
+                                   Gnss_InterSystemBiasStructType &interSystemBias,
+                                   const qmiLocInterSystemBiasStructT_v02* pInterSysBias)
+{
+    LOC_LOGV("%s] Mask:%d, TimeBias:%f, TimeBiasUnc:%f,\n",
+             interSystem, pInterSysBias->validMask, pInterSysBias->timeBias,
+             pInterSysBias->timeBiasUnc);
+
+    interSystemBias.validMask    = pInterSysBias->validMask;
+    interSystemBias.timeBias     = pInterSysBias->timeBias;
+    interSystemBias.timeBiasUnc  = pInterSysBias->timeBiasUnc;
+}
+
+/* Constructor for LocApiV02 */
+LocApiV02 :: LocApiV02(const MsgTask* msgTask,
+                       LOC_API_ADAPTER_EVENT_MASK_T exMask,
+                       ContextBase* context):
+    LocApiBase(msgTask, exMask, context),
+    clientHandle(LOC_CLIENT_INVALID_HANDLE_VALUE),
+    dsClientIface(NULL),
+    dsClientHandle(NULL),
+    dsLibraryHandle(NULL),
+    mGnssMeasurementSupported(sup_unknown),
+    mQmiMask(0), mInSession(false),
+    mEngineOn(false), mMeasurementsStarted(false)
+{
+  // initialize loc_sync_req interface
+  loc_sync_req_init();
+
+  UTIL_READ_CONF(GPS_CONF_FILE,gps_conf_param_table);
+}
+
+/* Destructor for LocApiV02 */
+LocApiV02 :: ~LocApiV02()
+{
+    close();
+}
+
+LocApiBase* getLocApi(const MsgTask *msgTask,
+                      LOC_API_ADAPTER_EVENT_MASK_T exMask,
+                      ContextBase* context)
+{
+    return (LocApiBase*)LocApiV02::createLocApiV02(msgTask, exMask, context);
+}
+
+LocApiBase* LocApiV02::createLocApiV02(const MsgTask *msgTask,
+                      LOC_API_ADAPTER_EVENT_MASK_T exMask,
+                      ContextBase* context)
+{
+    if (NULL != msgTask) {
+        LOC_LOGE("%s:%d]: msgTask can not be NULL", __func__, __LINE__);
+        return NULL;
+    }
+    LOC_LOGD("%s:%d]: Creating new LocApiV02", __func__, __LINE__);
+    return new LocApiV02(msgTask, exMask, context);
+}
+
+/* Initialize a loc api v02 client AND
+   check which loc message are supported by modem */
+enum loc_api_adapter_err
+LocApiV02 :: open(LOC_API_ADAPTER_EVENT_MASK_T mask)
+{
+  enum loc_api_adapter_err rtv = LOC_API_ADAPTER_ERR_SUCCESS;
+  LOC_API_ADAPTER_EVENT_MASK_T newMask = mMask | (mask & ~mExcludedMask);
+  locClientEventMaskType qmiMask = convertMask(newMask);
+  LOC_LOGD("%s:%d]: Enter mMask: %x; mask: %x; newMask: %x mQmiMask: %lld qmiMask: %lld",
+           __func__, __LINE__, mMask, mask, newMask, mQmiMask, qmiMask);
+  /* If the client is already open close it first */
+  if(LOC_CLIENT_INVALID_HANDLE_VALUE == clientHandle)
+  {
+    locClientStatusEnumType status = eLOC_CLIENT_SUCCESS;
+
+    LOC_LOGV ("%s:%d]: reference to this = %p passed in \n",
+              __func__, __LINE__, this);
+    /* initialize the loc api v02 interface, note that
+       the locClientOpen() function will block if the
+       service is unavailable for a fixed time out */
+
+    // it is important to cap the mask here, because not all LocApi's
+    // can enable the same bits, e.g. foreground and bckground.
+    status = locClientOpen(adjustMaskForNoSession(qmiMask), &globalCallbacks,
+                           &clientHandle, (void *)this);
+    mMask = newMask;
+    mQmiMask = qmiMask;
+    if (eLOC_CLIENT_SUCCESS != status ||
+        clientHandle == LOC_CLIENT_INVALID_HANDLE_VALUE )
+    {
+      mMask = 0;
+      mQmiMask = 0;
+      LOC_LOGE ("%s:%d]: locClientOpen failed, status = %s\n", __func__,
+                __LINE__, loc_get_v02_client_status_name(status));
+      rtv = LOC_API_ADAPTER_ERR_FAILURE;
+    } else {
+        uint64_t supportedMsgList = 0;
+        const uint32_t msgArray[NUMBER_OF_MSG_TO_BE_CHECKED] =
+        {
+            // For - LOC_API_ADAPTER_MESSAGE_LOCATION_BATCHING
+            QMI_LOC_GET_BATCH_SIZE_REQ_V02,
+
+            // For - LOC_API_ADAPTER_MESSAGE_BATCHED_GENFENCE_BREACH
+            QMI_LOC_EVENT_GEOFENCE_BATCHED_BREACH_NOTIFICATION_IND_V02,
+
+            // For - LOC_API_ADAPTER_MESSAGE_DISTANCE_BASE_TRACKING
+            QMI_LOC_START_DBT_REQ_V02
+        };
+
+        // check the modem
+        status = locClientSupportMsgCheck(clientHandle,
+                                          msgArray,
+                                          NUMBER_OF_MSG_TO_BE_CHECKED,
+                                          &supportedMsgList);
+        if (eLOC_CLIENT_SUCCESS != status) {
+            LOC_LOGE("%s:%d]: Failed to checking QMI_LOC message supported. \n",
+                     __func__, __LINE__);
+        }
+
+        /** if batching is supported , check if the adaptive batching or
+            distance-based batching is supported. */
+        uint32_t messageChecker = 1 << LOC_API_ADAPTER_MESSAGE_LOCATION_BATCHING;
+        if ((messageChecker & supportedMsgList) == messageChecker) {
+            locClientReqUnionType req_union;
+            locClientStatusEnumType status = eLOC_CLIENT_SUCCESS;
+            qmiLocQueryAonConfigReqMsgT_v02 queryAonConfigReq;
+            qmiLocQueryAonConfigIndMsgT_v02 queryAonConfigInd;
+
+            memset(&queryAonConfigReq, 0, sizeof(queryAonConfigReq));
+            memset(&queryAonConfigInd, 0, sizeof(queryAonConfigInd));
+            queryAonConfigReq.transactionId = LOC_API_V02_DEF_SESSION_ID;
+
+            req_union.pQueryAonConfigReq = &queryAonConfigReq;
+            status = loc_sync_send_req(clientHandle,
+                                       QMI_LOC_QUERY_AON_CONFIG_REQ_V02,
+                                       req_union,
+                                       LOC_ENGINE_SYNC_REQUEST_TIMEOUT,
+                                       QMI_LOC_QUERY_AON_CONFIG_IND_V02,
+                                       &queryAonConfigInd);
+
+            if (status == eLOC_CLIENT_FAILURE_UNSUPPORTED) {
+                LOC_LOGE("%s:%d]: Query AON config is not supported.\n", __func__, __LINE__);
+            } else {
+                if (status != eLOC_CLIENT_SUCCESS ||
+                    queryAonConfigInd.status != eQMI_LOC_SUCCESS_V02) {
+                    LOC_LOGE("%s:%d]: Query AON config failed."
+                             " status: %s, ind status:%s\n",
+                             __func__, __LINE__,
+                             loc_get_v02_client_status_name(status),
+                             loc_get_v02_qmi_status_name(queryAonConfigInd.status));
+                } else {
+                    LOC_LOGD("%s:%d]: Query AON config succeeded. aonCapability is %d.\n",
+                             __func__, __LINE__, queryAonConfigInd.aonCapability);
+                    if (queryAonConfigInd.aonCapability_valid) {
+                        if (queryAonConfigInd.aonCapability |
+                            QMI_LOC_MASK_AON_TIME_BASED_BATCHING_SUPPORTED_V02) {
+                            LOC_LOGD("%s:%d]: LB 1.0 is supported.\n", __func__, __LINE__);
+                        }
+                        if (queryAonConfigInd.aonCapability |
+                            QMI_LOC_MASK_AON_AUTO_BATCHING_SUPPORTED_V02) {
+                            LOC_LOGD("%s:%d]: LB 1.5 is supported.\n", __func__, __LINE__);
+                            supportedMsgList |=
+                                (1 << LOC_API_ADAPTER_MESSAGE_ADAPTIVE_LOCATION_BATCHING);
+                        }
+                        if (queryAonConfigInd.aonCapability |
+                            QMI_LOC_MASK_AON_DISTANCE_BASED_BATCHING_SUPPORTED_V02) {
+                            LOC_LOGD("%s:%d]: LB 2.0 is supported.\n", __func__, __LINE__);
+                            supportedMsgList |=
+                                (1 << LOC_API_ADAPTER_MESSAGE_DISTANCE_BASE_LOCATION_BATCHING);
+                        }
+                        if (queryAonConfigInd.aonCapability |
+                            QMI_LOC_MASK_AON_DISTANCE_BASED_TRACKING_SUPPORTED_V02) {
+                            LOC_LOGD("%s:%d]: DBT 2.0 is supported.\n", __func__, __LINE__);
+                        }
+                        if (queryAonConfigInd.aonCapability |
+                            QMI_LOC_MASK_AON_UPDATE_TBF_SUPPORTED_V02) {
+                            LOC_LOGD("%s:%d]: Updating tracking TBF on the fly is supported.\n",
+                                     __func__, __LINE__);
+                            supportedMsgList |=
+                                (1 << LOC_API_ADAPTER_MESSAGE_UPDATE_TBF_ON_THE_FLY);
+                        }
+                    } else {
+                        LOC_LOGE("%s:%d]: AON capability is invalid.\n", __func__, __LINE__);
+                    }
+                }
+            }
+        }
+        LOC_LOGV("%s:%d]: supportedMsgList is %lld. \n",
+                 __func__, __LINE__, supportedMsgList);
+        // save the supported message list
+        saveSupportedMsgList(supportedMsgList);
+
+        // Query for supported feature list
+        locClientReqUnionType req_union;
+        locClientStatusEnumType status = eLOC_CLIENT_SUCCESS;
+        qmiLocGetSupportedFeatureReqMsgT_v02 getSupportedFeatureList_req;
+        qmiLocGetSupportedFeatureIndMsgT_v02 getSupportedFeatureList_ind;
+
+        memset(&getSupportedFeatureList_req, 0, sizeof(getSupportedFeatureList_req));
+        memset(&getSupportedFeatureList_ind, 0, sizeof(getSupportedFeatureList_ind));
+
+        req_union.pGetSupportedFeatureReq = &getSupportedFeatureList_req;
+        status = loc_sync_send_req(clientHandle,
+                                   QMI_LOC_GET_SUPPORTED_FEATURE_REQ_V02,
+                                   req_union,
+                                   LOC_ENGINE_SYNC_REQUEST_TIMEOUT,
+                                   QMI_LOC_GET_SUPPORTED_FEATURE_IND_V02,
+                                   &getSupportedFeatureList_ind);
+        if (eLOC_CLIENT_SUCCESS != status) {
+            LOC_LOGE("%s:%d:%d]: Failed to get features supported from "
+                     "QMI_LOC_GET_SUPPORTED_FEATURE_REQ_V02. \n", __func__, __LINE__, status);
+        } else {
+            LOC_LOGD("%s:%d:%d]: Got list of features supported of length:%d ",
+                     __func__, __LINE__, getSupportedFeatureList_ind.feature_len);
+            for (int i = 0; i < getSupportedFeatureList_ind.feature_len; i++) {
+                LOC_LOGD("Bit-mask of supported features at index:%d is %d",i,
+                         getSupportedFeatureList_ind.feature[i]);
+            }
+            if (getSupportedFeatureList_ind.feature_len > 0) {
+                saveSupportedFeatureList(getSupportedFeatureList_ind.feature);
+            }
+        }
+    }
+  } else if (newMask != mMask) {
+    // it is important to cap the mask here, because not all LocApi's
+    // can enable the same bits, e.g. foreground and background.
+    if (!registerEventMask(qmiMask)) {
+      // we do not update mMask here, because it did not change
+      // as the mask update has failed.
+      rtv = LOC_API_ADAPTER_ERR_FAILURE;
+    }
+    else {
+        mMask = newMask;
+        mQmiMask = qmiMask;
+    }
+  }
+  /*Set the SV Measurement Constellation when Measurement Report or Polynomial report is set*/
+  if( (qmiMask & QMI_LOC_EVENT_MASK_GNSS_MEASUREMENT_REPORT_V02) ||
+      (qmiMask & QMI_LOC_EVENT_MASK_GNSS_SV_POLYNOMIAL_REPORT_V02) )
+  {
+     setSvMeasurementConstellation(eQMI_SYSTEM_GPS_V02|eQMI_SYSTEM_GLO_V02);
+  }
+  LOC_LOGD("%s:%d]: Exit mMask: %x; mask: %x mQmiMask: %lld qmiMask: %lld",
+           __func__, __LINE__, mMask, mask, mQmiMask, qmiMask);
+
+  if (LOC_API_ADAPTER_ERR_SUCCESS == rtv) {
+      cacheGnssMeasurementSupport();
+  }
+
+  return rtv;
+}
+
+bool LocApiV02 :: registerEventMask(locClientEventMaskType qmiMask)
+{
+    if (!mInSession) {
+        qmiMask = adjustMaskForNoSession(qmiMask);
+    }
+    LOC_LOGD("%s:%d]: mQmiMask=%lld qmiMask=%lld",
+             __func__, __LINE__, mQmiMask, qmiMask);
+    return locClientRegisterEventMask(clientHandle, qmiMask);
+}
+
+locClientEventMaskType LocApiV02 :: adjustMaskForNoSession(locClientEventMaskType qmiMask)
+{
+    LOC_LOGD("%s:%d]: before qmiMask=%lld",
+             __func__, __LINE__, qmiMask);
+    locClientEventMaskType clearMask = QMI_LOC_EVENT_MASK_POSITION_REPORT_V02 |
+                                       QMI_LOC_EVENT_MASK_GNSS_SV_INFO_V02 |
+                                       QMI_LOC_EVENT_MASK_NMEA_V02 |
+                                       QMI_LOC_EVENT_MASK_ENGINE_STATE_V02 |
+                                       QMI_LOC_EVENT_MASK_GNSS_MEASUREMENT_REPORT_V02;
+
+    qmiMask = qmiMask & ~clearMask;
+    LOC_LOGD("%s:%d]: after qmiMask=%lld",
+             __func__, __LINE__, qmiMask);
+    return qmiMask;
+}
+
+enum loc_api_adapter_err LocApiV02 :: close()
+{
+  enum loc_api_adapter_err rtv =
+      // success if either client is already invalid, or
+      // we successfully close the handle
+      (LOC_CLIENT_INVALID_HANDLE_VALUE == clientHandle ||
+       eLOC_CLIENT_SUCCESS == locClientClose(&clientHandle)) ?
+      LOC_API_ADAPTER_ERR_SUCCESS : LOC_API_ADAPTER_ERR_FAILURE;
+
+  mMask = 0;
+  clientHandle = LOC_CLIENT_INVALID_HANDLE_VALUE;
+
+  return rtv;
+}
+
+/* start positioning session */
+enum loc_api_adapter_err LocApiV02 :: startFix(const LocPosMode& fixCriteria)
+{
+  locClientStatusEnumType status;
+  locClientReqUnionType req_union;
+
+  qmiLocStartReqMsgT_v02 start_msg;
+
+  qmiLocSetOperationModeReqMsgT_v02 set_mode_msg;
+  qmiLocSetOperationModeIndMsgT_v02 set_mode_ind;
+
+    // clear all fields, validity masks
+  memset (&start_msg, 0, sizeof(start_msg));
+  memset (&set_mode_msg, 0, sizeof(set_mode_msg));
+  memset (&set_mode_ind, 0, sizeof(set_mode_ind));
+
+  LOC_LOGV("%s:%d]: start \n", __func__, __LINE__);
+  fixCriteria.logv();
+
+  mInSession = true;
+  mMeasurementsStarted = true;
+  registerEventMask(mQmiMask);
+
+  // fill in the start request
+  switch(fixCriteria.mode)
+  {
+    case LOC_POSITION_MODE_MS_BASED:
+      set_mode_msg.operationMode = eQMI_LOC_OPER_MODE_MSB_V02;
+      break;
+
+    case LOC_POSITION_MODE_MS_ASSISTED:
+      set_mode_msg.operationMode = eQMI_LOC_OPER_MODE_MSA_V02;
+      break;
+
+    case LOC_POSITION_MODE_RESERVED_4:
+      set_mode_msg.operationMode = eQMI_LOC_OPER_MODE_CELL_ID_V02;
+        break;
+
+    case LOC_POSITION_MODE_RESERVED_5:
+      set_mode_msg.operationMode = eQMI_LOC_OPER_MODE_WWAN_V02;
+        break;
+
+    default:
+      set_mode_msg.operationMode = eQMI_LOC_OPER_MODE_STANDALONE_V02;
+      break;
+  }
+
+  req_union.pSetOperationModeReq = &set_mode_msg;
+
+  // send the mode first, before the start message.
+  status = loc_sync_send_req(clientHandle,
+                             QMI_LOC_SET_OPERATION_MODE_REQ_V02,
+                             req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT,
+                             QMI_LOC_SET_OPERATION_MODE_IND_V02,
+                             &set_mode_ind); // NULL?
+   //When loc_sync_send_req status is time out, more likely the response was lost.
+   //startFix will continue as though it is succeeded.
+  if ((status != eLOC_CLIENT_SUCCESS && status != eLOC_CLIENT_FAILURE_TIMEOUT) ||
+       eQMI_LOC_SUCCESS_V02 != set_mode_ind.status)
+  {
+    LOC_LOGE ("%s:%d]: set opertion mode failed status = %s, "
+                   "ind..status = %s\n", __func__, __LINE__,
+              loc_get_v02_client_status_name(status),
+              loc_get_v02_qmi_status_name(set_mode_ind.status));
+  } else {
+      if (status == eLOC_CLIENT_FAILURE_TIMEOUT)
+      {
+          LOC_LOGE ("%s:%d]: set operation mode timed out\n", __func__, __LINE__);
+      }
+      start_msg.minInterval_valid = 1;
+      start_msg.minInterval = fixCriteria.min_interval;
+
+      if (fixCriteria.preferred_accuracy >= 0) {
+          start_msg.horizontalAccuracyLevel_valid = 1;
+
+          if (fixCriteria.preferred_accuracy <= 100)
+          {
+              // fix needs high accuracy
+              start_msg.horizontalAccuracyLevel =  eQMI_LOC_ACCURACY_HIGH_V02;
+          }
+          else if (fixCriteria.preferred_accuracy <= 1000)
+          {
+              //fix needs med accuracy
+              start_msg.horizontalAccuracyLevel =  eQMI_LOC_ACCURACY_MED_V02;
+          }
+          else
+          {
+              //fix needs low accuracy
+              start_msg.horizontalAccuracyLevel =  eQMI_LOC_ACCURACY_LOW_V02;
+          }
+      }
+
+      start_msg.fixRecurrence_valid = 1;
+      if(GPS_POSITION_RECURRENCE_SINGLE == fixCriteria.recurrence)
+      {
+          start_msg.fixRecurrence = eQMI_LOC_RECURRENCE_SINGLE_V02;
+      }
+      else
+      {
+          start_msg.fixRecurrence = eQMI_LOC_RECURRENCE_PERIODIC_V02;
+      }
+
+      //dummy session id
+      // TBD: store session ID, check for session id in pos reports.
+      start_msg.sessionId = LOC_API_V02_DEF_SESSION_ID;
+
+      //Set whether position report can be shared with other LOC clients
+      start_msg.sharePosition_valid = 1;
+      start_msg.sharePosition = fixCriteria.share_position;
+
+      if (fixCriteria.credentials[0] != 0) {
+          int size1 = sizeof(start_msg.applicationId.applicationName);
+          int size2 = sizeof(fixCriteria.credentials);
+          int len = ((size1 < size2) ? size1 : size2) - 1;
+          memcpy(start_msg.applicationId.applicationName,
+                 fixCriteria.credentials,
+                 len);
+
+          size1 = sizeof(start_msg.applicationId.applicationProvider);
+          size2 = sizeof(fixCriteria.provider);
+          len = ((size1 < size2) ? size1 : size2) - 1;
+          memcpy(start_msg.applicationId.applicationProvider,
+                 fixCriteria.provider,
+                 len);
+
+          start_msg.applicationId_valid = 1;
+      }
+
+      // config Altitude Assumed
+      start_msg.configAltitudeAssumed_valid = 1;
+      start_msg.configAltitudeAssumed = eQMI_LOC_ALTITUDE_ASSUMED_IN_GNSS_SV_INFO_DISABLED_V02;
+
+      req_union.pStartReq = &start_msg;
+
+      status = locClientSendReq (clientHandle, QMI_LOC_START_REQ_V02,
+                                 req_union );
+  }
+
+  return convertErr(status);
+}
+
+/* stop a positioning session */
+enum loc_api_adapter_err LocApiV02 :: stopFix()
+{
+  locClientStatusEnumType status;
+  locClientReqUnionType req_union;
+
+  qmiLocStopReqMsgT_v02 stop_msg;
+
+  LOC_LOGD(" %s:%d]: stop called \n", __func__, __LINE__);
+
+  memset(&stop_msg, 0, sizeof(stop_msg));
+
+  // dummy session id
+  stop_msg.sessionId = LOC_API_V02_DEF_SESSION_ID;
+
+  req_union.pStopReq = &stop_msg;
+
+  status = locClientSendReq(clientHandle,
+                            QMI_LOC_STOP_REQ_V02,
+                            req_union);
+
+  mInSession = false;
+  // if engine on never happend, deregister events
+  // without waiting for Engine Off
+  if (!mEngineOn) {
+      registerEventMask(mQmiMask);
+  }
+
+  if( eLOC_CLIENT_SUCCESS != status)
+  {
+      LOC_LOGE("%s:%d]: error = %s\n",__func__, __LINE__,
+               loc_get_v02_client_status_name(status));
+  }
+
+  return convertErr(status);
+}
+
+/* set the positioning fix criteria */
+enum loc_api_adapter_err LocApiV02 :: setPositionMode(
+  const LocPosMode& posMode)
+{
+    if(isInSession())
+    {
+        //fix is in progress, send a restart
+        LOC_LOGD ("%s:%d]: fix is in progress restarting the fix with new "
+                  "criteria\n", __func__, __LINE__);
+
+        return( startFix(posMode));
+    }
+
+    return LOC_API_ADAPTER_ERR_SUCCESS;
+}
+
+/* inject time into the position engine */
+enum loc_api_adapter_err LocApiV02 ::
+    setTime(GpsUtcTime time, int64_t timeReference, int uncertainty)
+{
+  locClientReqUnionType req_union;
+  locClientStatusEnumType status;
+  qmiLocInjectUtcTimeReqMsgT_v02  inject_time_msg;
+  qmiLocInjectUtcTimeIndMsgT_v02 inject_time_ind;
+
+  memset(&inject_time_msg, 0, sizeof(inject_time_msg));
+
+  inject_time_ind.status = eQMI_LOC_GENERAL_FAILURE_V02;
+
+  inject_time_msg.timeUtc = time;
+
+  inject_time_msg.timeUtc += (int64_t)(platform_lib_abstraction_elapsed_millis_since_boot() - timeReference);
+
+  inject_time_msg.timeUnc = uncertainty;
+
+  req_union.pInjectUtcTimeReq = &inject_time_msg;
+
+  LOC_LOGV ("%s:%d]: uncertainty = %d\n", __func__, __LINE__,
+                 uncertainty);
+
+  status = loc_sync_send_req(clientHandle,
+                             QMI_LOC_INJECT_UTC_TIME_REQ_V02,
+                             req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT,
+                             QMI_LOC_INJECT_UTC_TIME_IND_V02,
+                             &inject_time_ind);
+
+  if (status != eLOC_CLIENT_SUCCESS ||
+      eQMI_LOC_SUCCESS_V02 != inject_time_ind.status)
+  {
+    LOC_LOGE ("%s:%d] status = %s, ind..status = %s\n", __func__,  __LINE__,
+              loc_get_v02_client_status_name(status),
+              loc_get_v02_qmi_status_name(inject_time_ind.status));
+  }
+
+  return convertErr(status);
+}
+
+/* inject position into the position engine */
+enum loc_api_adapter_err LocApiV02 ::
+    injectPosition(double latitude, double longitude, float accuracy)
+{
+  locClientReqUnionType req_union;
+  locClientStatusEnumType status;
+  qmiLocInjectPositionReqMsgT_v02 inject_pos_msg;
+  qmiLocInjectPositionIndMsgT_v02 inject_pos_ind;
+
+  memset(&inject_pos_msg, 0, sizeof(inject_pos_msg));
+  memset(&inject_pos_ind, 0, sizeof(inject_pos_ind));
+
+  inject_pos_msg.latitude_valid = 1;
+  inject_pos_msg.latitude = latitude;
+
+  inject_pos_msg.longitude_valid = 1;
+  inject_pos_msg.longitude = longitude;
+
+  inject_pos_msg.horUncCircular_valid = 1;
+
+  inject_pos_msg.horUncCircular = accuracy; //meters assumed
+  if (inject_pos_msg.horUncCircular < 1000) {
+      inject_pos_msg.horUncCircular = 1000;
+  }
+
+  inject_pos_msg.horConfidence_valid = 1;
+
+  inject_pos_msg.horConfidence = 68; //1 std dev assumed as specified by API
+
+  inject_pos_msg.rawHorUncCircular_valid = 1;
+
+  inject_pos_msg.rawHorUncCircular = accuracy; //meters assumed
+
+  inject_pos_msg.rawHorConfidence_valid = 1;
+
+  inject_pos_msg.rawHorConfidence = 68; //1 std dev assumed as specified by API
+
+  struct timespec time_info_current;
+  if(clock_gettime(CLOCK_REALTIME,&time_info_current) == 0) //success
+  {
+      inject_pos_msg.timestampUtc_valid = 1;
+      inject_pos_msg.timestampUtc = (time_info_current.tv_sec)*1e3 +
+          (time_info_current.tv_nsec)/1e6;
+      LOC_LOGV("%s:%d] inject timestamp from system: %llu",
+               __func__, __LINE__, inject_pos_msg.timestampUtc);
+  }
+
+  /* Log */
+  LOC_LOGD("%s:%d]: Lat=%lf, Lon=%lf, Acc=%.2lf rawAcc=%.2lf", __func__, __LINE__,
+                inject_pos_msg.latitude, inject_pos_msg.longitude,
+                inject_pos_msg.horUncCircular, inject_pos_msg.rawHorUncCircular);
+
+  req_union.pInjectPositionReq = &inject_pos_msg;
+
+  status = loc_sync_send_req(clientHandle,
+                             QMI_LOC_INJECT_POSITION_REQ_V02,
+                             req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT,
+                             QMI_LOC_INJECT_POSITION_IND_V02,
+                             &inject_pos_ind);
+
+  if (status != eLOC_CLIENT_SUCCESS ||
+      eQMI_LOC_SUCCESS_V02 != inject_pos_ind.status)
+  {
+    LOC_LOGE ("%s:%d]: error! status = %s, inject_pos_ind.status = %s\n",
+              __func__, __LINE__,
+              loc_get_v02_client_status_name(status),
+              loc_get_v02_qmi_status_name(inject_pos_ind.status));
+  }
+
+  return convertErr(status);
+}
+
+/* delete assistance date */
+enum loc_api_adapter_err LocApiV02 ::  deleteAidingData(GpsAidingData f)
+{
+  static bool isNewApiSupported = true;
+  locClientReqUnionType req_union;
+  locClientStatusEnumType status = eLOC_CLIENT_FAILURE_UNSUPPORTED;
+
+  // Use the new API first
+  qmiLocDeleteGNSSServiceDataReqMsgT_v02 delete_gnss_req;
+  qmiLocDeleteGNSSServiceDataIndMsgT_v02 delete_gnss_resp;
+
+  memset(&delete_gnss_req, 0, sizeof(delete_gnss_req));
+  memset(&delete_gnss_resp, 0, sizeof(delete_gnss_resp));
+
+  if (isNewApiSupported)
+  {
+      if (GPS_DELETE_ALL == f)
+      {
+          delete_gnss_req.deleteAllFlag = true;
+      }
+      else
+      {
+          if (f & GPS_DELETE_EPHEMERIS)
+          {
+              delete_gnss_req.deleteSatelliteData_valid = 1;
+              delete_gnss_req.deleteSatelliteData.deleteSatelliteDataMask |= QMI_LOC_DELETE_DATA_MASK_EPHEMERIS_V02;
+          }
+
+          if (f & GPS_DELETE_ALMANAC)
+          {
+              delete_gnss_req.deleteSatelliteData_valid = 1;
+              delete_gnss_req.deleteSatelliteData.deleteSatelliteDataMask |= QMI_LOC_DELETE_DATA_MASK_ALMANAC_V02;
+          }
+
+          if (f & GPS_DELETE_POSITION)
+          {
+              delete_gnss_req.deleteCommonDataMask_valid = 1;
+              delete_gnss_req.deleteCommonDataMask |= QMI_LOC_DELETE_COMMON_MASK_POS_V02;
+          }
+
+          if (f & GPS_DELETE_TIME)
+          {
+              delete_gnss_req.deleteCommonDataMask_valid = 1;
+              delete_gnss_req.deleteCommonDataMask |= QMI_LOC_DELETE_COMMON_MASK_TIME_V02;
+
+              delete_gnss_req.deleteSatelliteData_valid = 1;
+              delete_gnss_req.deleteSatelliteData.deleteSatelliteDataMask |= QMI_LOC_DELETE_DATA_MASK_TIME_V02;
+          }
+
+          if (f & GPS_DELETE_IONO)
+          {
+              delete_gnss_req.deleteSatelliteData_valid = 1;
+              delete_gnss_req.deleteSatelliteData.deleteSatelliteDataMask |= QMI_LOC_DELETE_DATA_MASK_IONO_V02;
+          }
+
+          if (f & GPS_DELETE_UTC)
+          {
+              delete_gnss_req.deleteCommonDataMask_valid = 1;
+              delete_gnss_req.deleteCommonDataMask |= QMI_LOC_DELETE_COMMON_MASK_UTC_V02;
+          }
+
+          if (f & GPS_DELETE_HEALTH)
+          {
+              delete_gnss_req.deleteSatelliteData_valid = 1;
+              delete_gnss_req.deleteSatelliteData.deleteSatelliteDataMask |= QMI_LOC_DELETE_DATA_MASK_SVHEALTH_V02;
+          }
+
+          if (f & GPS_DELETE_SVDIR)
+          {
+              delete_gnss_req.deleteSatelliteData_valid = 1;
+              delete_gnss_req.deleteSatelliteData.deleteSatelliteDataMask |= QMI_LOC_DELETE_DATA_MASK_SVDIR_V02;
+          }
+
+          if (f & GPS_DELETE_SVSTEER)
+          {
+              delete_gnss_req.deleteSatelliteData_valid = 1;
+              delete_gnss_req.deleteSatelliteData.deleteSatelliteDataMask |= QMI_LOC_DELETE_DATA_MASK_SVSTEER_V02;
+          }
+
+          if (f & GPS_DELETE_SADATA)
+          {
+              delete_gnss_req.deleteSatelliteData_valid = 1;
+              delete_gnss_req.deleteSatelliteData.deleteSatelliteDataMask |= QMI_LOC_DELETE_DATA_MASK_SA_DATA_V02;
+          }
+
+          if (f & GPS_DELETE_RTI)
+          {
+              delete_gnss_req.deleteCommonDataMask_valid = 1;
+              delete_gnss_req.deleteCommonDataMask |= QMI_LOC_DELETE_COMMON_MASK_RTI_V02;
+          }
+
+          if (delete_gnss_req.deleteSatelliteData_valid)
+          {
+              delete_gnss_req.deleteSatelliteData.system |= QMI_LOC_SYSTEM_GPS_V02;
+              delete_gnss_req.deleteSatelliteData.system |= QMI_LOC_SYSTEM_GLO_V02;
+              delete_gnss_req.deleteSatelliteData.system |= QMI_LOC_SYSTEM_BDS_V02;
+              delete_gnss_req.deleteSatelliteData.system |= QMI_LOC_SYSTEM_GAL_V02;
+              delete_gnss_req.deleteSatelliteData.system |= QMI_LOC_SYSTEM_QZSS_V02;
+          }
+
+          if (f & GPS_DELETE_CELLDB_INFO)
+          {
+              delete_gnss_req.deleteCellDbDataMask_valid = 1;
+              delete_gnss_req.deleteCellDbDataMask =
+                  (QMI_LOC_MASK_DELETE_CELLDB_POS_V02 |
+                      QMI_LOC_MASK_DELETE_CELLDB_LATEST_GPS_POS_V02 |
+                      QMI_LOC_MASK_DELETE_CELLDB_OTA_POS_V02 |
+                      QMI_LOC_MASK_DELETE_CELLDB_EXT_REF_POS_V02 |
+                      QMI_LOC_MASK_DELETE_CELLDB_TIMETAG_V02 |
+                      QMI_LOC_MASK_DELETE_CELLDB_CELLID_V02 |
+                      QMI_LOC_MASK_DELETE_CELLDB_CACHED_CELLID_V02 |
+                      QMI_LOC_MASK_DELETE_CELLDB_LAST_SRV_CELL_V02 |
+                      QMI_LOC_MASK_DELETE_CELLDB_CUR_SRV_CELL_V02 |
+                      QMI_LOC_MASK_DELETE_CELLDB_NEIGHBOR_INFO_V02);
+
+          }
+      }
+
+      req_union.pDeleteGNSSServiceDataReq = &delete_gnss_req;
+
+      status = loc_sync_send_req(clientHandle,
+          QMI_LOC_DELETE_GNSS_SERVICE_DATA_REQ_V02,
+          req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT,
+          QMI_LOC_DELETE_GNSS_SERVICE_DATA_IND_V02,
+          &delete_gnss_resp);
+
+      if (status != eLOC_CLIENT_SUCCESS ||
+          eQMI_LOC_SUCCESS_V02 != delete_gnss_resp.status)
+      {
+          LOC_LOGE("%s:%d]: error! status = %s, delete_resp.status = %s\n",
+              __func__, __LINE__,
+              loc_get_v02_client_status_name(status),
+              loc_get_v02_qmi_status_name(delete_gnss_resp.status));
+      }
+  }
+
+  if (eLOC_CLIENT_FAILURE_UNSUPPORTED == status ||
+      eLOC_CLIENT_FAILURE_INTERNAL == status) {
+      // If the new API is not supported we fall back on the old one
+      // The error could be eLOC_CLIENT_FAILURE_INTERNAL if
+      // QMI_LOC_DELETE_GNSS_SERVICE_DATA_REQ_V02 is not in the .idl file
+      LOC_LOGD("%s:%d]: QMI_LOC_DELETE_GNSS_SERVICE_DATA_REQ_V02 not supported"
+          "We use QMI_LOC_DELETE_ASSIST_DATA_REQ_V02\n",
+          __func__, __LINE__);
+      isNewApiSupported = false;
+
+      qmiLocDeleteAssistDataReqMsgT_v02 delete_req;
+      qmiLocDeleteAssistDataIndMsgT_v02 delete_resp;
+
+      memset(&delete_req, 0, sizeof(delete_req));
+      memset(&delete_resp, 0, sizeof(delete_resp));
+
+      if (f == GPS_DELETE_ALL)
+      {
+          delete_req.deleteAllFlag = true;
+      }
+      else
+      {
+          /* to keep track of svInfoList for GPS and GLO*/
+          uint32_t curr_sv_len = 0;
+          uint32_t curr_sv_idx = 0;
+          uint32_t sv_id = 0;
+
+          if ((f & GPS_DELETE_EPHEMERIS) || (f & GPS_DELETE_ALMANAC))
+          {
+              /* do delete for all GPS SV's */
+
+              curr_sv_len += SV_ID_RANGE;
+
+              sv_id = GPS_SV_ID_OFFSET;
+
+              delete_req.deleteSvInfoList_valid = 1;
+
+              delete_req.deleteSvInfoList_len = curr_sv_len;
+
+              LOC_LOGV("%s:%d]: Delete GPS SV info for index %d to %d"
+                  "and sv id %d to %d \n",
+                  __func__, __LINE__, curr_sv_idx, curr_sv_len - 1,
+                  sv_id, sv_id + SV_ID_RANGE - 1);
+
+              for (uint32_t i = curr_sv_idx; i < curr_sv_len; i++, sv_id++)
+              {
+                  delete_req.deleteSvInfoList[i].gnssSvId = sv_id;
+
+                  delete_req.deleteSvInfoList[i].system = eQMI_LOC_SV_SYSTEM_GPS_V02;
+
+                  if (f & GPS_DELETE_EPHEMERIS)
+                  {
+                      // set ephemeris mask for all GPS SV's
+                      delete_req.deleteSvInfoList[i].deleteSvInfoMask |=
+                          QMI_LOC_MASK_DELETE_EPHEMERIS_V02;
+                  }
+
+                  if (f & GPS_DELETE_ALMANAC)
+                  {
+                      delete_req.deleteSvInfoList[i].deleteSvInfoMask |=
+                          QMI_LOC_MASK_DELETE_ALMANAC_V02;
+                  }
+              }
+              // increment the current index
+              curr_sv_idx += SV_ID_RANGE;
+
+          }
+
+          if (f & GPS_DELETE_POSITION)
+          {
+              delete_req.deleteGnssDataMask_valid = 1;
+              delete_req.deleteGnssDataMask |= QMI_LOC_MASK_DELETE_POSITION_V02;
+          }
+
+          if (f & GPS_DELETE_TIME)
+          {
+              delete_req.deleteGnssDataMask_valid = 1;
+              delete_req.deleteGnssDataMask |= QMI_LOC_MASK_DELETE_TIME_V02;
+          }
+
+          if (f & GPS_DELETE_IONO)
+          {
+              delete_req.deleteGnssDataMask_valid = 1;
+              delete_req.deleteGnssDataMask |= QMI_LOC_MASK_DELETE_IONO_V02;
+          }
+
+          if (f & GPS_DELETE_UTC)
+          {
+              delete_req.deleteGnssDataMask_valid = 1;
+              delete_req.deleteGnssDataMask |= QMI_LOC_MASK_DELETE_UTC_V02;
+          }
+
+          if (f & GPS_DELETE_HEALTH)
+          {
+              delete_req.deleteGnssDataMask_valid = 1;
+              delete_req.deleteGnssDataMask |= QMI_LOC_MASK_DELETE_HEALTH_V02;
+          }
+
+          if (f & GPS_DELETE_SVDIR)
+          {
+              delete_req.deleteGnssDataMask_valid = 1;
+              delete_req.deleteGnssDataMask |= QMI_LOC_MASK_DELETE_GPS_SVDIR_V02;
+          }
+          if (f & GPS_DELETE_SADATA)
+          {
+              delete_req.deleteGnssDataMask_valid = 1;
+              delete_req.deleteGnssDataMask |= QMI_LOC_MASK_DELETE_SADATA_V02;
+          }
+          if (f & GPS_DELETE_RTI)
+          {
+              delete_req.deleteGnssDataMask_valid = 1;
+              delete_req.deleteGnssDataMask |= QMI_LOC_MASK_DELETE_RTI_V02;
+          }
+          if (f & GPS_DELETE_CELLDB_INFO)
+          {
+              delete_req.deleteCellDbDataMask_valid = 1;
+              delete_req.deleteCellDbDataMask =
+                  (QMI_LOC_MASK_DELETE_CELLDB_POS_V02 |
+                      QMI_LOC_MASK_DELETE_CELLDB_LATEST_GPS_POS_V02 |
+                      QMI_LOC_MASK_DELETE_CELLDB_OTA_POS_V02 |
+                      QMI_LOC_MASK_DELETE_CELLDB_EXT_REF_POS_V02 |
+                      QMI_LOC_MASK_DELETE_CELLDB_TIMETAG_V02 |
+                      QMI_LOC_MASK_DELETE_CELLDB_CELLID_V02 |
+                      QMI_LOC_MASK_DELETE_CELLDB_CACHED_CELLID_V02 |
+                      QMI_LOC_MASK_DELETE_CELLDB_LAST_SRV_CELL_V02 |
+                      QMI_LOC_MASK_DELETE_CELLDB_CUR_SRV_CELL_V02 |
+                      QMI_LOC_MASK_DELETE_CELLDB_NEIGHBOR_INFO_V02);
+
+          }
+      }
+
+      req_union.pDeleteAssistDataReq = &delete_req;
+
+      status = loc_sync_send_req(clientHandle,
+          QMI_LOC_DELETE_ASSIST_DATA_REQ_V02,
+          req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT,
+          QMI_LOC_DELETE_ASSIST_DATA_IND_V02,
+          &delete_resp);
+
+      if (status != eLOC_CLIENT_SUCCESS ||
+          eQMI_LOC_SUCCESS_V02 != delete_resp.status)
+      {
+          LOC_LOGE("%s:%d]: error! status = %s, delete_resp.status = %s\n",
+              __func__, __LINE__,
+              loc_get_v02_client_status_name(status),
+              loc_get_v02_qmi_status_name(delete_resp.status));
+      }
+  }
+  return convertErr(status);
+}
+
+/* send NI user repsonse to the engine */
+enum loc_api_adapter_err LocApiV02 ::
+    informNiResponse(GpsUserResponseType userResponse,
+                     const void* passThroughData)
+{
+  locClientReqUnionType req_union;
+  locClientStatusEnumType status;
+
+  qmiLocNiUserRespReqMsgT_v02 ni_resp;
+  qmiLocNiUserRespIndMsgT_v02 ni_resp_ind;
+
+  qmiLocEventNiNotifyVerifyReqIndMsgT_v02 *request_pass_back =
+    (qmiLocEventNiNotifyVerifyReqIndMsgT_v02 *)passThroughData;
+
+  memset(&ni_resp,0, sizeof(ni_resp));
+
+  memset(&ni_resp_ind,0, sizeof(ni_resp_ind));
+
+  switch (userResponse)
+  {
+    case GPS_NI_RESPONSE_ACCEPT:
+      ni_resp.userResp = eQMI_LOC_NI_LCS_NOTIFY_VERIFY_ACCEPT_V02;
+      break;
+   case GPS_NI_RESPONSE_DENY:
+      ni_resp.userResp = eQMI_LOC_NI_LCS_NOTIFY_VERIFY_DENY_V02;
+      break;
+   case GPS_NI_RESPONSE_NORESP:
+      ni_resp.userResp = eQMI_LOC_NI_LCS_NOTIFY_VERIFY_NORESP_V02;
+      break;
+   default:
+      return LOC_API_ADAPTER_ERR_INVALID_PARAMETER;
+  }
+
+  LOC_LOGV(" %s:%d]: NI response: %d\n", __func__, __LINE__,
+                ni_resp.userResp);
+
+  ni_resp.notificationType = request_pass_back->notificationType;
+
+  // copy SUPL payload from request
+  if(request_pass_back->NiSuplInd_valid == 1)
+  {
+     ni_resp.NiSuplPayload_valid = 1;
+     memcpy(&(ni_resp.NiSuplPayload), &(request_pass_back->NiSuplInd),
+            sizeof(qmiLocNiSuplNotifyVerifyStructT_v02));
+
+  }
+  // should this be an "else if"?? we don't need to decide
+
+  // copy UMTS-CP payload from request
+  if( request_pass_back->NiUmtsCpInd_valid == 1 )
+  {
+     ni_resp.NiUmtsCpPayload_valid = 1;
+     memcpy(&(ni_resp.NiUmtsCpPayload), &(request_pass_back->NiUmtsCpInd),
+            sizeof(qmiLocNiUmtsCpNotifyVerifyStructT_v02));
+  }
+
+  //copy Vx payload from the request
+  if( request_pass_back->NiVxInd_valid == 1)
+  {
+     ni_resp.NiVxPayload_valid = 1;
+     memcpy(&(ni_resp.NiVxPayload), &(request_pass_back->NiVxInd),
+            sizeof(qmiLocNiVxNotifyVerifyStructT_v02));
+  }
+
+  // copy Vx service interaction payload from the request
+  if(request_pass_back->NiVxServiceInteractionInd_valid == 1)
+  {
+     ni_resp.NiVxServiceInteractionPayload_valid = 1;
+     memcpy(&(ni_resp.NiVxServiceInteractionPayload),
+            &(request_pass_back->NiVxServiceInteractionInd),
+            sizeof(qmiLocNiVxServiceInteractionStructT_v02));
+  }
+
+  // copy Network Initiated SUPL Version 2 Extension
+  if (request_pass_back->NiSuplVer2ExtInd_valid == 1)
+  {
+     ni_resp.NiSuplVer2ExtPayload_valid = 1;
+     memcpy(&(ni_resp.NiSuplVer2ExtPayload),
+            &(request_pass_back->NiSuplVer2ExtInd),
+            sizeof(qmiLocNiSuplVer2ExtStructT_v02));
+  }
+
+  // copy SUPL Emergency Notification
+  if(request_pass_back->suplEmergencyNotification_valid)
+  {
+     ni_resp.suplEmergencyNotification_valid = 1;
+     memcpy(&(ni_resp.suplEmergencyNotification),
+            &(request_pass_back->suplEmergencyNotification),
+            sizeof(qmiLocEmergencyNotificationStructT_v02));
+  }
+
+  req_union.pNiUserRespReq = &ni_resp;
+
+  status = loc_sync_send_req (
+     clientHandle, QMI_LOC_NI_USER_RESPONSE_REQ_V02,
+     req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT,
+     QMI_LOC_NI_USER_RESPONSE_IND_V02, &ni_resp_ind);
+
+  if (status != eLOC_CLIENT_SUCCESS ||
+      eQMI_LOC_SUCCESS_V02 != ni_resp_ind.status)
+  {
+    LOC_LOGE ("%s:%d]: error! status = %s, ni_resp_ind.status = %s\n",
+              __func__, __LINE__,
+              loc_get_v02_client_status_name(status),
+              loc_get_v02_qmi_status_name(ni_resp_ind.status));
+  }
+
+  return convertErr(status);
+}
+
+/* Set UMTs SLP server URL */
+enum loc_api_adapter_err LocApiV02 :: setServer(
+  const char* url, int len)
+{
+  locClientReqUnionType req_union;
+  locClientStatusEnumType status;
+  qmiLocSetServerReqMsgT_v02 set_server_req;
+  qmiLocSetServerIndMsgT_v02 set_server_ind;
+
+  if(len < 0 || len > sizeof(set_server_req.urlAddr))
+  {
+    LOC_LOGE("%s:%d]: len = %d greater than max allowed url length\n",
+                  __func__, __LINE__, len);
+
+    return LOC_API_ADAPTER_ERR_INVALID_PARAMETER;
+  }
+
+  memset(&set_server_req, 0, sizeof(set_server_req));
+  memset(&set_server_ind, 0, sizeof(set_server_ind));
+
+  LOC_LOGD("%s:%d]:, url = %s, len = %d\n", __func__, __LINE__, url, len);
+
+  set_server_req.serverType = eQMI_LOC_SERVER_TYPE_UMTS_SLP_V02;
+
+  set_server_req.urlAddr_valid = 1;
+
+  strlcpy(set_server_req.urlAddr, url, sizeof(set_server_req.urlAddr));
+
+  req_union.pSetServerReq = &set_server_req;
+
+  status = loc_sync_send_req(clientHandle,
+                             QMI_LOC_SET_SERVER_REQ_V02,
+                             req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT,
+                             QMI_LOC_SET_SERVER_IND_V02,
+                             &set_server_ind);
+
+  if (status != eLOC_CLIENT_SUCCESS ||
+         eQMI_LOC_SUCCESS_V02 != set_server_ind.status)
+  {
+    LOC_LOGE ("%s:%d]: error status = %s, set_server_ind.status = %s\n",
+              __func__,__LINE__,
+              loc_get_v02_client_status_name(status),
+              loc_get_v02_qmi_status_name(set_server_ind.status));
+  }
+
+  return convertErr(status);
+}
+
+enum loc_api_adapter_err LocApiV02 ::
+    setServer(unsigned int ip, int port, LocServerType type)
+{
+  locClientReqUnionType req_union;
+  locClientStatusEnumType status;
+  qmiLocSetServerReqMsgT_v02 set_server_req;
+  qmiLocSetServerIndMsgT_v02 set_server_ind;
+  qmiLocServerTypeEnumT_v02 set_server_cmd;
+
+  switch (type) {
+  case LOC_AGPS_MPC_SERVER:
+      set_server_cmd = eQMI_LOC_SERVER_TYPE_CDMA_MPC_V02;
+      break;
+  case LOC_AGPS_CUSTOM_PDE_SERVER:
+      set_server_cmd = eQMI_LOC_SERVER_TYPE_CUSTOM_PDE_V02;
+      break;
+  default:
+      set_server_cmd = eQMI_LOC_SERVER_TYPE_CDMA_PDE_V02;
+      break;
+  }
+
+  memset(&set_server_req, 0, sizeof(set_server_req));
+  memset(&set_server_ind, 0, sizeof(set_server_ind));
+
+  LOC_LOGD("%s:%d]:, ip = %u, port = %d\n", __func__, __LINE__, ip, port);
+
+  set_server_req.serverType = set_server_cmd;
+  set_server_req.ipv4Addr_valid = 1;
+  set_server_req.ipv4Addr.addr = ip;
+  set_server_req.ipv4Addr.port = port;
+
+  req_union.pSetServerReq = &set_server_req;
+
+  status = loc_sync_send_req(clientHandle,
+                             QMI_LOC_SET_SERVER_REQ_V02,
+                             req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT,
+                             QMI_LOC_SET_SERVER_IND_V02,
+                             &set_server_ind);
+
+  if (status != eLOC_CLIENT_SUCCESS ||
+      eQMI_LOC_SUCCESS_V02 != set_server_ind.status)
+  {
+    LOC_LOGE ("%s:%d]: error status = %s, set_server_ind.status = %s\n",
+              __func__,__LINE__,
+              loc_get_v02_client_status_name(status),
+              loc_get_v02_qmi_status_name(set_server_ind.status));
+  }
+
+  return convertErr(status);
+}
+
+/* Inject XTRA data, this module breaks down the XTRA
+   file into "chunks" and injects them one at a time */
+enum loc_api_adapter_err LocApiV02 :: setXtraData(
+  char* data, int length)
+{
+  locClientStatusEnumType status = eLOC_CLIENT_SUCCESS;
+  int     total_parts;
+  uint8_t   part;
+  uint16_t  len_injected;
+
+  locClientReqUnionType req_union;
+  qmiLocInjectPredictedOrbitsDataReqMsgT_v02 inject_xtra;
+  qmiLocInjectPredictedOrbitsDataIndMsgT_v02 inject_xtra_ind;
+
+  req_union.pInjectPredictedOrbitsDataReq = &inject_xtra;
+
+  LOC_LOGD("%s:%d]: xtra size = %d\n", __func__, __LINE__, length);
+
+  inject_xtra.formatType_valid = 1;
+  inject_xtra.formatType = eQMI_LOC_PREDICTED_ORBITS_XTRA_V02;
+  inject_xtra.totalSize = length;
+
+  total_parts = ((length - 1) / QMI_LOC_MAX_PREDICTED_ORBITS_PART_LEN_V02) + 1;
+
+  inject_xtra.totalParts = total_parts;
+
+  len_injected = 0; // O bytes injected
+
+  // XTRA injection starts with part 1
+  for (part = 1; part <= total_parts; part++)
+  {
+    inject_xtra.partNum = part;
+
+    if (QMI_LOC_MAX_PREDICTED_ORBITS_PART_LEN_V02 > (length - len_injected))
+    {
+      inject_xtra.partData_len = length - len_injected;
+    }
+    else
+    {
+      inject_xtra.partData_len = QMI_LOC_MAX_PREDICTED_ORBITS_PART_LEN_V02;
+    }
+
+    // copy data into the message
+    memcpy(inject_xtra.partData, data+len_injected, inject_xtra.partData_len);
+
+    LOC_LOGD("[%s:%d] part %d/%d, len = %d, total injected = %d\n",
+                  __func__, __LINE__,
+                  inject_xtra.partNum, total_parts, inject_xtra.partData_len,
+                  len_injected);
+
+    memset(&inject_xtra_ind, 0, sizeof(inject_xtra_ind));
+    status = loc_sync_send_req( clientHandle,
+                                QMI_LOC_INJECT_PREDICTED_ORBITS_DATA_REQ_V02,
+                                req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT,
+                                QMI_LOC_INJECT_PREDICTED_ORBITS_DATA_IND_V02,
+                                &inject_xtra_ind);
+
+    if (status != eLOC_CLIENT_SUCCESS ||
+        eQMI_LOC_SUCCESS_V02 != inject_xtra_ind.status ||
+        inject_xtra.partNum != inject_xtra_ind.partNum)
+    {
+      LOC_LOGE ("%s:%d]: failed status = %s, inject_pos_ind.status = %s,"
+                     " part num = %d, ind.partNum = %d\n", __func__, __LINE__,
+                loc_get_v02_client_status_name(status),
+                loc_get_v02_qmi_status_name(inject_xtra_ind.status),
+                inject_xtra.partNum, inject_xtra_ind.partNum);
+    } else {
+      len_injected += inject_xtra.partData_len;
+      LOC_LOGD("%s:%d]: XTRA injected length: %d\n", __func__, __LINE__,
+               len_injected);
+    }
+  }
+
+  return convertErr(status);
+}
+
+/* Request the Xtra Server Url from the modem */
+enum loc_api_adapter_err LocApiV02 :: requestXtraServer()
+{
+  locClientStatusEnumType status = eLOC_CLIENT_SUCCESS;
+
+  locClientReqUnionType req_union;
+  qmiLocGetPredictedOrbitsDataSourceIndMsgT_v02 request_xtra_server_ind;
+
+  memset(&request_xtra_server_ind, 0, sizeof(request_xtra_server_ind));
+
+  status = loc_sync_send_req( clientHandle,
+                              QMI_LOC_GET_PREDICTED_ORBITS_DATA_SOURCE_REQ_V02,
+                              req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT,
+                              QMI_LOC_GET_PREDICTED_ORBITS_DATA_SOURCE_IND_V02,
+                              &request_xtra_server_ind);
+
+  if (status == eLOC_CLIENT_SUCCESS &&
+      eQMI_LOC_SUCCESS_V02 == request_xtra_server_ind.status &&
+      false != request_xtra_server_ind.serverList_valid &&
+      0 != request_xtra_server_ind.serverList.serverList_len)
+  {
+    if (request_xtra_server_ind.serverList.serverList_len == 1)
+    {
+      reportXtraServer(request_xtra_server_ind.serverList.serverList[0].serverUrl,
+                       "",
+                       "",
+                       QMI_LOC_MAX_SERVER_ADDR_LENGTH_V02);
+    }
+    else if (request_xtra_server_ind.serverList.serverList_len == 2)
+    {
+      reportXtraServer(request_xtra_server_ind.serverList.serverList[0].serverUrl,
+                       request_xtra_server_ind.serverList.serverList[1].serverUrl,
+                       "",
+                       QMI_LOC_MAX_SERVER_ADDR_LENGTH_V02);
+    }
+    else
+    {
+      reportXtraServer(request_xtra_server_ind.serverList.serverList[0].serverUrl,
+                       request_xtra_server_ind.serverList.serverList[1].serverUrl,
+                       request_xtra_server_ind.serverList.serverList[2].serverUrl,
+                       QMI_LOC_MAX_SERVER_ADDR_LENGTH_V02);
+    }
+  }
+
+  return convertErr(status);
+}
+
+enum loc_api_adapter_err LocApiV02 :: atlOpenStatus(
+  int handle, int is_succ, char* apn, AGpsBearerType bear,
+  AGpsType agpsType)
+{
+  locClientStatusEnumType result = eLOC_CLIENT_SUCCESS;
+  locClientReqUnionType req_union;
+  qmiLocInformLocationServerConnStatusReqMsgT_v02 conn_status_req;
+  qmiLocInformLocationServerConnStatusIndMsgT_v02 conn_status_ind;
+
+
+  LOC_LOGD("%s:%d]: ATL open handle = %d, is_succ = %d, "
+                "APN = [%s], bearer = %d \n",  __func__, __LINE__,
+                handle, is_succ, apn, bear);
+
+  memset(&conn_status_req, 0, sizeof(conn_status_req));
+  memset(&conn_status_ind, 0, sizeof(conn_status_ind));
+
+        // Fill in data
+  conn_status_req.connHandle = handle;
+
+  conn_status_req.requestType = eQMI_LOC_SERVER_REQUEST_OPEN_V02;
+
+  if(is_succ)
+  {
+    conn_status_req.statusType = eQMI_LOC_SERVER_REQ_STATUS_SUCCESS_V02;
+
+    if(apn != NULL)
+        strlcpy(conn_status_req.apnProfile.apnName, apn,
+                sizeof(conn_status_req.apnProfile.apnName) );
+
+    switch(bear)
+    {
+    case AGPS_APN_BEARER_IPV4:
+        conn_status_req.apnProfile.pdnType =
+            eQMI_LOC_APN_PROFILE_PDN_TYPE_IPV4_V02;
+        conn_status_req.apnProfile_valid = 1;
+        break;
+
+    case AGPS_APN_BEARER_IPV6:
+        conn_status_req.apnProfile.pdnType =
+            eQMI_LOC_APN_PROFILE_PDN_TYPE_IPV6_V02;
+        conn_status_req.apnProfile_valid = 1;
+        break;
+
+    case AGPS_APN_BEARER_IPV4V6:
+        conn_status_req.apnProfile.pdnType =
+            eQMI_LOC_APN_PROFILE_PDN_TYPE_IPV4V6_V02;
+        conn_status_req.apnProfile_valid = 1;
+        break;
+
+    case AGPS_APN_BEARER_INVALID:
+        conn_status_req.apnProfile_valid = 0;
+        break;
+
+    default:
+        LOC_LOGE("%s:%d]:invalid bearer type\n",__func__,__LINE__);
+        conn_status_req.apnProfile_valid = 0;
+        return LOC_API_ADAPTER_ERR_INVALID_HANDLE;
+    }
+
+  }
+  else
+  {
+    conn_status_req.statusType = eQMI_LOC_SERVER_REQ_STATUS_FAILURE_V02;
+  }
+
+  req_union.pInformLocationServerConnStatusReq = &conn_status_req;
+
+  result = loc_sync_send_req(clientHandle,
+                             QMI_LOC_INFORM_LOCATION_SERVER_CONN_STATUS_REQ_V02,
+                             req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT,
+                             QMI_LOC_INFORM_LOCATION_SERVER_CONN_STATUS_IND_V02,
+                             &conn_status_ind);
+
+  if(result != eLOC_CLIENT_SUCCESS ||
+     eQMI_LOC_SUCCESS_V02 != conn_status_ind.status)
+  {
+    LOC_LOGE ("%s:%d]: Error status = %s, ind..status = %s ",
+              __func__, __LINE__,
+              loc_get_v02_client_status_name(result),
+              loc_get_v02_qmi_status_name(conn_status_ind.status));
+  }
+
+  return convertErr(result);
+
+}
+
+
+/* close atl connection */
+enum loc_api_adapter_err LocApiV02 :: atlCloseStatus(
+  int handle, int is_succ)
+{
+  locClientStatusEnumType result = eLOC_CLIENT_SUCCESS;
+  locClientReqUnionType req_union;
+  qmiLocInformLocationServerConnStatusReqMsgT_v02 conn_status_req;
+  qmiLocInformLocationServerConnStatusIndMsgT_v02 conn_status_ind;
+
+  LOC_LOGD("%s:%d]: ATL close handle = %d, is_succ = %d\n",
+                 __func__, __LINE__,  handle, is_succ);
+
+  memset(&conn_status_req, 0, sizeof(conn_status_req));
+  memset(&conn_status_ind, 0, sizeof(conn_status_ind));
+
+        // Fill in data
+  conn_status_req.connHandle = handle;
+
+  conn_status_req.requestType = eQMI_LOC_SERVER_REQUEST_CLOSE_V02;
+
+  if(is_succ)
+  {
+    conn_status_req.statusType = eQMI_LOC_SERVER_REQ_STATUS_SUCCESS_V02;
+  }
+  else
+  {
+    conn_status_req.statusType = eQMI_LOC_SERVER_REQ_STATUS_FAILURE_V02;
+  }
+
+  req_union.pInformLocationServerConnStatusReq = &conn_status_req;
+
+  result = loc_sync_send_req(clientHandle,
+                             QMI_LOC_INFORM_LOCATION_SERVER_CONN_STATUS_REQ_V02,
+                             req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT,
+                             QMI_LOC_INFORM_LOCATION_SERVER_CONN_STATUS_IND_V02,
+                             &conn_status_ind);
+
+  if(result != eLOC_CLIENT_SUCCESS ||
+     eQMI_LOC_SUCCESS_V02 != conn_status_ind.status)
+  {
+    LOC_LOGE ("%s:%d]: Error status = %s, ind..status = %s ",
+              __func__, __LINE__,
+              loc_get_v02_client_status_name(result),
+              loc_get_v02_qmi_status_name(conn_status_ind.status));
+  }
+
+  return convertErr(result);
+}
+
+/* set the SUPL version */
+enum loc_api_adapter_err LocApiV02 :: setSUPLVersion(uint32_t version)
+{
+  locClientStatusEnumType result = eLOC_CLIENT_SUCCESS;
+  locClientReqUnionType req_union;
+
+  qmiLocSetProtocolConfigParametersReqMsgT_v02 supl_config_req;
+  qmiLocSetProtocolConfigParametersIndMsgT_v02 supl_config_ind;
+
+  LOC_LOGD("%s:%d]: supl version = %d\n",  __func__, __LINE__, version);
+
+
+  memset(&supl_config_req, 0, sizeof(supl_config_req));
+  memset(&supl_config_ind, 0, sizeof(supl_config_ind));
+
+   supl_config_req.suplVersion_valid = 1;
+   // SUPL version from MSByte to LSByte:
+   // (reserved)(major version)(minor version)(serviceIndicator)
+
+   if(version == 0x00020000) {
+       supl_config_req.suplVersion = eQMI_LOC_SUPL_VERSION_2_0_V02;
+   } else if (version == 0x00020002) {
+       supl_config_req.suplVersion = eQMI_LOC_SUPL_VERSION_2_0_2_V02;
+   } else {
+       supl_config_req.suplVersion =  eQMI_LOC_SUPL_VERSION_1_0_V02;
+   }
+
+  req_union.pSetProtocolConfigParametersReq = &supl_config_req;
+
+  result = loc_sync_send_req(clientHandle,
+                             QMI_LOC_SET_PROTOCOL_CONFIG_PARAMETERS_REQ_V02,
+                             req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT,
+                             QMI_LOC_SET_PROTOCOL_CONFIG_PARAMETERS_IND_V02,
+                             &supl_config_ind);
+
+  if(result != eLOC_CLIENT_SUCCESS ||
+     eQMI_LOC_SUCCESS_V02 != supl_config_ind.status)
+  {
+    LOC_LOGE ("%s:%d]: Error status = %s, ind..status = %s ",
+              __func__, __LINE__,
+              loc_get_v02_client_status_name(result),
+              loc_get_v02_qmi_status_name(supl_config_ind.status));
+  }
+
+  return convertErr(result);
+}
+
+/* set the NMEA types mask */
+enum loc_api_adapter_err LocApiV02 :: setNMEATypes (uint32_t typesMask)
+{
+  locClientStatusEnumType result = eLOC_CLIENT_SUCCESS;
+  locClientReqUnionType req_union;
+
+  qmiLocSetNmeaTypesReqMsgT_v02 setNmeaTypesReqMsg;
+  qmiLocSetNmeaTypesIndMsgT_v02 setNmeaTypesIndMsg;
+
+  LOC_LOGD(" %s:%d]: setNMEATypes, mask = %u\n", __func__, __LINE__,typesMask);
+
+  memset(&setNmeaTypesReqMsg, 0, sizeof(setNmeaTypesReqMsg));
+  memset(&setNmeaTypesIndMsg, 0, sizeof(setNmeaTypesIndMsg));
+
+  setNmeaTypesReqMsg.nmeaSentenceType = typesMask;
+
+  req_union.pSetNmeaTypesReq = &setNmeaTypesReqMsg;
+
+  result = loc_sync_send_req( clientHandle,
+          QMI_LOC_SET_NMEA_TYPES_REQ_V02, req_union,
+          LOC_ENGINE_SYNC_REQUEST_TIMEOUT,
+          QMI_LOC_SET_NMEA_TYPES_IND_V02, &setNmeaTypesIndMsg);
+
+  // if success
+  if ( result != eLOC_CLIENT_SUCCESS )
+  {
+    LOC_LOGE ("%s:%d]: Error status = %s, ind..status = %s ",
+                  __func__, __LINE__,
+                  loc_get_v02_client_status_name(result),
+                  loc_get_v02_qmi_status_name(setNmeaTypesIndMsg.status));
+  }
+
+  return convertErr(result);
+}
+
+/* set the configuration for LTE positioning profile (LPP) */
+enum loc_api_adapter_err LocApiV02 :: setLPPConfig(uint32_t profile)
+{
+  locClientStatusEnumType result = eLOC_CLIENT_SUCCESS;
+  locClientReqUnionType req_union;
+  qmiLocSetProtocolConfigParametersReqMsgT_v02 lpp_config_req;
+  qmiLocSetProtocolConfigParametersIndMsgT_v02 lpp_config_ind;
+
+  LOC_LOGD("%s:%d]: lpp profile = %d\n",  __func__, __LINE__, profile);
+
+  memset(&lpp_config_req, 0, sizeof(lpp_config_req));
+  memset(&lpp_config_ind, 0, sizeof(lpp_config_ind));
+
+  lpp_config_req.lppConfig_valid = 1;
+
+  lpp_config_req.lppConfig = profile;
+
+  req_union.pSetProtocolConfigParametersReq = &lpp_config_req;
+
+  result = loc_sync_send_req(clientHandle,
+                             QMI_LOC_SET_PROTOCOL_CONFIG_PARAMETERS_REQ_V02,
+                             req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT,
+                             QMI_LOC_SET_PROTOCOL_CONFIG_PARAMETERS_IND_V02,
+                             &lpp_config_ind);
+
+  if(result != eLOC_CLIENT_SUCCESS ||
+     eQMI_LOC_SUCCESS_V02 != lpp_config_ind.status)
+  {
+    LOC_LOGE ("%s:%d]: Error status = %s, ind..status = %s ",
+              __func__, __LINE__,
+              loc_get_v02_client_status_name(result),
+              loc_get_v02_qmi_status_name(lpp_config_ind.status));
+  }
+
+  return convertErr(result);
+}
+
+/* set the Sensor Configuration */
+enum loc_api_adapter_err LocApiV02 :: setSensorControlConfig(
+    int sensorsDisabled, int sensorProvider)
+{
+  locClientStatusEnumType result = eLOC_CLIENT_SUCCESS;
+  locClientReqUnionType req_union;
+
+  qmiLocSetSensorControlConfigReqMsgT_v02 sensor_config_req;
+  qmiLocSetSensorControlConfigIndMsgT_v02 sensor_config_ind;
+
+  LOC_LOGD("%s:%d]: sensors disabled = %d\n",  __func__, __LINE__, sensorsDisabled);
+
+  memset(&sensor_config_req, 0, sizeof(sensor_config_req));
+  memset(&sensor_config_ind, 0, sizeof(sensor_config_ind));
+
+  sensor_config_req.sensorsUsage_valid = 1;
+  sensor_config_req.sensorsUsage = (sensorsDisabled == 1) ? eQMI_LOC_SENSOR_CONFIG_SENSOR_USE_DISABLE_V02
+                                    : eQMI_LOC_SENSOR_CONFIG_SENSOR_USE_ENABLE_V02;
+
+  sensor_config_req.sensorProvider_valid = 1;
+  sensor_config_req.sensorProvider = (sensorProvider == 1 || sensorProvider == 4) ?
+      eQMI_LOC_SENSOR_CONFIG_USE_PROVIDER_SSC_V02 :
+      eQMI_LOC_SENSOR_CONFIG_USE_PROVIDER_NATIVE_V02;
+
+  req_union.pSetSensorControlConfigReq = &sensor_config_req;
+
+  result = loc_sync_send_req(clientHandle,
+                             QMI_LOC_SET_SENSOR_CONTROL_CONFIG_REQ_V02,
+                             req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT,
+                             QMI_LOC_SET_SENSOR_CONTROL_CONFIG_IND_V02,
+                             &sensor_config_ind);
+
+  if(result != eLOC_CLIENT_SUCCESS ||
+     eQMI_LOC_SUCCESS_V02 != sensor_config_ind.status)
+  {
+    LOC_LOGE ("%s:%d]: Error status = %s, ind..status = %s ",
+              __func__, __LINE__,
+              loc_get_v02_client_status_name(result),
+              loc_get_v02_qmi_status_name(sensor_config_ind.status));
+  }
+
+  return convertErr(result);
+}
+
+/* set the Sensor Properties */
+enum loc_api_adapter_err LocApiV02 :: setSensorProperties(bool gyroBiasVarianceRandomWalk_valid, float gyroBiasVarianceRandomWalk,
+                            bool accelBiasVarianceRandomWalk_valid, float accelBiasVarianceRandomWalk,
+                            bool angleBiasVarianceRandomWalk_valid, float angleBiasVarianceRandomWalk,
+                            bool rateBiasVarianceRandomWalk_valid, float rateBiasVarianceRandomWalk,
+                            bool velocityBiasVarianceRandomWalk_valid, float velocityBiasVarianceRandomWalk)
+{
+  locClientStatusEnumType result = eLOC_CLIENT_SUCCESS;
+  locClientReqUnionType req_union;
+
+  qmiLocSetSensorPropertiesReqMsgT_v02 sensor_prop_req;
+  qmiLocSetSensorPropertiesIndMsgT_v02 sensor_prop_ind;
+
+  LOC_LOGI("%s:%d]: sensors prop: gyroBiasRandomWalk = %f, accelRandomWalk = %f, "
+           "angleRandomWalk = %f, rateRandomWalk = %f, velocityRandomWalk = %f\n",
+                 __func__, __LINE__, gyroBiasVarianceRandomWalk, accelBiasVarianceRandomWalk,
+           angleBiasVarianceRandomWalk, rateBiasVarianceRandomWalk, velocityBiasVarianceRandomWalk);
+
+  memset(&sensor_prop_req, 0, sizeof(sensor_prop_req));
+  memset(&sensor_prop_ind, 0, sizeof(sensor_prop_ind));
+
+  /* Set the validity bit and value for each sensor property */
+  sensor_prop_req.gyroBiasVarianceRandomWalk_valid = gyroBiasVarianceRandomWalk_valid;
+  sensor_prop_req.gyroBiasVarianceRandomWalk = gyroBiasVarianceRandomWalk;
+
+  sensor_prop_req.accelerationRandomWalkSpectralDensity_valid = accelBiasVarianceRandomWalk_valid;
+  sensor_prop_req.accelerationRandomWalkSpectralDensity = accelBiasVarianceRandomWalk;
+
+  sensor_prop_req.angleRandomWalkSpectralDensity_valid = angleBiasVarianceRandomWalk_valid;
+  sensor_prop_req.angleRandomWalkSpectralDensity = angleBiasVarianceRandomWalk;
+
+  sensor_prop_req.rateRandomWalkSpectralDensity_valid = rateBiasVarianceRandomWalk_valid;
+  sensor_prop_req.rateRandomWalkSpectralDensity = rateBiasVarianceRandomWalk;
+
+  sensor_prop_req.velocityRandomWalkSpectralDensity_valid = velocityBiasVarianceRandomWalk_valid;
+  sensor_prop_req.velocityRandomWalkSpectralDensity = velocityBiasVarianceRandomWalk;
+
+  req_union.pSetSensorPropertiesReq = &sensor_prop_req;
+
+  result = loc_sync_send_req(clientHandle,
+                             QMI_LOC_SET_SENSOR_PROPERTIES_REQ_V02,
+                             req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT,
+                             QMI_LOC_SET_SENSOR_PROPERTIES_IND_V02,
+                             &sensor_prop_ind);
+
+  if(result != eLOC_CLIENT_SUCCESS ||
+     eQMI_LOC_SUCCESS_V02 != sensor_prop_ind.status)
+  {
+    LOC_LOGE ("%s:%d]: Error status = %s, ind..status = %s ",
+              __func__, __LINE__,
+              loc_get_v02_client_status_name(result),
+              loc_get_v02_qmi_status_name(sensor_prop_ind.status));
+  }
+
+  return convertErr(result);
+}
+
+/* set the Sensor Performance Config */
+enum loc_api_adapter_err LocApiV02 :: setSensorPerfControlConfig(int controlMode,
+                                                                        int accelSamplesPerBatch, int accelBatchesPerSec,
+                                                                        int gyroSamplesPerBatch, int gyroBatchesPerSec,
+                                                                        int accelSamplesPerBatchHigh, int accelBatchesPerSecHigh,
+                                                                        int gyroSamplesPerBatchHigh, int gyroBatchesPerSecHigh,
+                                                                        int algorithmConfig)
+{
+  locClientStatusEnumType result = eLOC_CLIENT_SUCCESS;
+  locClientReqUnionType req_union;
+
+  qmiLocSetSensorPerformanceControlConfigReqMsgT_v02 sensor_perf_config_req;
+  qmiLocSetSensorPerformanceControlConfigIndMsgT_v02 sensor_perf_config_ind;
+
+  LOC_LOGD("%s:%d]: Sensor Perf Control Config (performanceControlMode)(%u) "
+                "accel(#smp,#batches) (%u,%u) gyro(#smp,#batches) (%u,%u) "
+                "accel_high(#smp,#batches) (%u,%u) gyro_high(#smp,#batches) (%u,%u) "
+                "algorithmConfig(%u)\n",
+                __FUNCTION__,
+                __LINE__,
+                controlMode,
+                accelSamplesPerBatch,
+                accelBatchesPerSec,
+                gyroSamplesPerBatch,
+                gyroBatchesPerSec,
+                accelSamplesPerBatchHigh,
+                accelBatchesPerSecHigh,
+                gyroSamplesPerBatchHigh,
+                gyroBatchesPerSecHigh,
+                algorithmConfig
+                );
+
+  memset(&sensor_perf_config_req, 0, sizeof(sensor_perf_config_req));
+  memset(&sensor_perf_config_ind, 0, sizeof(sensor_perf_config_ind));
+
+  sensor_perf_config_req.performanceControlMode_valid = 1;
+  sensor_perf_config_req.performanceControlMode = (qmiLocSensorPerformanceControlModeEnumT_v02)controlMode;
+  sensor_perf_config_req.accelSamplingSpec_valid = 1;
+  sensor_perf_config_req.accelSamplingSpec.batchesPerSecond = accelBatchesPerSec;
+  sensor_perf_config_req.accelSamplingSpec.samplesPerBatch = accelSamplesPerBatch;
+  sensor_perf_config_req.gyroSamplingSpec_valid = 1;
+  sensor_perf_config_req.gyroSamplingSpec.batchesPerSecond = gyroBatchesPerSec;
+  sensor_perf_config_req.gyroSamplingSpec.samplesPerBatch = gyroSamplesPerBatch;
+  sensor_perf_config_req.accelSamplingSpecHigh_valid = 1;
+  sensor_perf_config_req.accelSamplingSpecHigh.batchesPerSecond = accelBatchesPerSecHigh;
+  sensor_perf_config_req.accelSamplingSpecHigh.samplesPerBatch = accelSamplesPerBatchHigh;
+  sensor_perf_config_req.gyroSamplingSpecHigh_valid = 1;
+  sensor_perf_config_req.gyroSamplingSpecHigh.batchesPerSecond = gyroBatchesPerSecHigh;
+  sensor_perf_config_req.gyroSamplingSpecHigh.samplesPerBatch = gyroSamplesPerBatchHigh;
+  sensor_perf_config_req.algorithmConfig_valid = 1;
+  sensor_perf_config_req.algorithmConfig = algorithmConfig;
+
+  req_union.pSetSensorPerformanceControlConfigReq = &sensor_perf_config_req;
+
+  result = loc_sync_send_req(clientHandle,
+                             QMI_LOC_SET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_REQ_V02,
+                             req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT,
+                             QMI_LOC_SET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_IND_V02,
+                             &sensor_perf_config_ind);
+
+  if(result != eLOC_CLIENT_SUCCESS ||
+     eQMI_LOC_SUCCESS_V02 != sensor_perf_config_ind.status)
+  {
+    LOC_LOGE ("%s:%d]: Error status = %s, ind..status = %s ",
+              __func__, __LINE__,
+              loc_get_v02_client_status_name(result),
+              loc_get_v02_qmi_status_name(sensor_perf_config_ind.status));
+  }
+
+  return convertErr(result);
+}
+
+/* set the Positioning Protocol on A-GLONASS system */
+enum loc_api_adapter_err LocApiV02 :: setAGLONASSProtocol(unsigned long aGlonassProtocol)
+{
+  locClientStatusEnumType result = eLOC_CLIENT_SUCCESS;
+  locClientReqUnionType req_union;
+  qmiLocSetProtocolConfigParametersReqMsgT_v02 aGlonassProtocol_req;
+  qmiLocSetProtocolConfigParametersIndMsgT_v02 aGlonassProtocol_ind;
+
+  memset(&aGlonassProtocol_req, 0, sizeof(aGlonassProtocol_req));
+  memset(&aGlonassProtocol_ind, 0, sizeof(aGlonassProtocol_ind));
+
+  aGlonassProtocol_req.assistedGlonassProtocolMask_valid = 1;
+  aGlonassProtocol_req.assistedGlonassProtocolMask = aGlonassProtocol;
+
+  req_union.pSetProtocolConfigParametersReq = &aGlonassProtocol_req;
+
+  LOC_LOGD("%s:%d]: aGlonassProtocolMask = 0x%x\n",  __func__, __LINE__,
+                             aGlonassProtocol_req.assistedGlonassProtocolMask);
+
+  result = loc_sync_send_req(clientHandle,
+                             QMI_LOC_SET_PROTOCOL_CONFIG_PARAMETERS_REQ_V02,
+                             req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT,
+                             QMI_LOC_SET_PROTOCOL_CONFIG_PARAMETERS_IND_V02,
+                             &aGlonassProtocol_ind);
+
+  if(result != eLOC_CLIENT_SUCCESS ||
+     eQMI_LOC_SUCCESS_V02 != aGlonassProtocol_ind.status)
+  {
+    LOC_LOGE ("%s:%d]: Error status = %s, ind..status = %s ",
+              __func__, __LINE__,
+              loc_get_v02_client_status_name(result),
+              loc_get_v02_qmi_status_name(aGlonassProtocol_ind.status));
+  }
+
+  return convertErr(result);
+}
+
+
+/* set the technology being used for LPPe control-plane and user-plane protocol */
+enum loc_api_adapter_err LocApiV02 :: setLPPeProtocol(unsigned long lppeCP,unsigned long lppeUP)
+{
+  locClientStatusEnumType result = eLOC_CLIENT_SUCCESS;
+  locClientReqUnionType req_union;
+  qmiLocSetProtocolConfigParametersReqMsgT_v02 lppe_req;
+  qmiLocSetProtocolConfigParametersIndMsgT_v02 lppe_ind;
+  //CP config
+  memset(&lppe_req, 0, sizeof(lppe_req));
+  memset(&lppe_ind, 0, sizeof(lppe_ind));
+
+  lppe_req.lppeCpConfig_valid = 1;
+  lppe_req.lppeCpConfig = lppeCP;
+
+  req_union.pSetProtocolConfigParametersReq = &lppe_req;
+
+  LOC_LOGD("%s:%d]: lppeCpConfig = 0x%x \n",  __func__, __LINE__,
+           lppe_req.lppeCpConfig);
+
+  result = loc_sync_send_req(clientHandle,
+                             QMI_LOC_SET_PROTOCOL_CONFIG_PARAMETERS_REQ_V02,
+                             req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT,
+                             QMI_LOC_SET_PROTOCOL_CONFIG_PARAMETERS_IND_V02,
+                             &lppe_ind);
+
+  if(result != eLOC_CLIENT_SUCCESS ||
+     eQMI_LOC_SUCCESS_V02 != lppe_ind.status)
+  {
+    LOC_LOGE ("%s:%d]: Error status = %s, ind..status = %s ",
+              __func__, __LINE__,
+              loc_get_v02_client_status_name(result),
+              loc_get_v02_qmi_status_name(lppe_ind.status));
+  }
+
+  //UP Config
+  memset(&lppe_req, 0, sizeof(lppe_req));
+  memset(&lppe_ind, 0, sizeof(lppe_ind));
+  memset(&req_union, 0, sizeof(req_union));
+
+  lppe_req.lppeUpConfig_valid = 1;
+  lppe_req.lppeUpConfig = lppeUP;
+
+  req_union.pSetProtocolConfigParametersReq = &lppe_req;
+
+  LOC_LOGD("%s:%d]: lppeUpConfig = 0x%x\n",  __func__, __LINE__,
+           lppe_req.lppeUpConfig);
+
+  result = loc_sync_send_req(clientHandle,
+                             QMI_LOC_SET_PROTOCOL_CONFIG_PARAMETERS_REQ_V02,
+                             req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT,
+                             QMI_LOC_SET_PROTOCOL_CONFIG_PARAMETERS_IND_V02,
+                             &lppe_ind);
+
+  if(result != eLOC_CLIENT_SUCCESS ||
+     eQMI_LOC_SUCCESS_V02 != lppe_ind.status)
+  {
+    LOC_LOGE ("%s:%d]: Error status = %s, ind..status = %s ",
+              __func__, __LINE__,
+              loc_get_v02_client_status_name(result),
+              loc_get_v02_qmi_status_name(lppe_ind.status));
+  }
+
+  return convertErr(result);
+}
+
+/* Convert event mask from loc eng to loc_api_v02 format */
+locClientEventMaskType LocApiV02 :: convertMask(
+  LOC_API_ADAPTER_EVENT_MASK_T mask)
+{
+  locClientEventMaskType eventMask = 0;
+  LOC_LOGD("%s:%d]: adapter mask = %u\n", __func__, __LINE__, mask);
+
+  if (mask & LOC_API_ADAPTER_BIT_PARSED_POSITION_REPORT)
+      eventMask |= QMI_LOC_EVENT_MASK_POSITION_REPORT_V02;
+
+  if (mask & LOC_API_ADAPTER_BIT_SATELLITE_REPORT)
+      eventMask |= QMI_LOC_EVENT_MASK_GNSS_SV_INFO_V02;
+
+  /* treat NMEA_1Hz and NMEA_POSITION_REPORT the same*/
+  if ((mask & LOC_API_ADAPTER_BIT_NMEA_POSITION_REPORT) ||
+      (mask & LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT) )
+      eventMask |= QMI_LOC_EVENT_MASK_NMEA_V02;
+
+  if (mask & LOC_API_ADAPTER_BIT_NI_NOTIFY_VERIFY_REQUEST)
+      eventMask |= QMI_LOC_EVENT_MASK_NI_NOTIFY_VERIFY_REQ_V02;
+
+  if (mask & LOC_API_ADAPTER_BIT_ASSISTANCE_DATA_REQUEST)
+  {
+    // TBD: This needs to be decoupled in the HAL
+    eventMask |= QMI_LOC_EVENT_MASK_INJECT_PREDICTED_ORBITS_REQ_V02;
+    eventMask |= QMI_LOC_EVENT_MASK_INJECT_TIME_REQ_V02;
+    eventMask |= QMI_LOC_EVENT_MASK_INJECT_POSITION_REQ_V02;
+  }
+
+  if (mask & LOC_API_ADAPTER_BIT_STATUS_REPORT)
+  {
+      eventMask |= (QMI_LOC_EVENT_MASK_ENGINE_STATE_V02);
+  }
+
+  if (mask & LOC_API_ADAPTER_BIT_LOCATION_SERVER_REQUEST)
+      eventMask |= QMI_LOC_EVENT_MASK_LOCATION_SERVER_CONNECTION_REQ_V02;
+
+  if (mask & LOC_API_ADAPTER_BIT_REQUEST_WIFI)
+      eventMask |= QMI_LOC_EVENT_MASK_WIFI_REQ_V02;
+
+  if (mask & LOC_API_ADAPTER_BIT_SENSOR_STATUS)
+      eventMask |= QMI_LOC_EVENT_MASK_SENSOR_STREAMING_READY_STATUS_V02;
+
+  if (mask & LOC_API_ADAPTER_BIT_REQUEST_TIME_SYNC)
+      eventMask |= QMI_LOC_EVENT_MASK_TIME_SYNC_REQ_V02;
+
+  if (mask & LOC_API_ADAPTER_BIT_REPORT_SPI)
+      eventMask |= QMI_LOC_EVENT_MASK_SET_SPI_STREAMING_REPORT_V02;
+
+  if (mask & LOC_API_ADAPTER_BIT_REPORT_NI_GEOFENCE)
+      eventMask |= QMI_LOC_EVENT_MASK_NI_GEOFENCE_NOTIFICATION_V02;
+
+  if (mask & LOC_API_ADAPTER_BIT_GEOFENCE_GEN_ALERT)
+      eventMask |= QMI_LOC_EVENT_MASK_GEOFENCE_GEN_ALERT_V02;
+
+  if (mask & LOC_API_ADAPTER_BIT_REPORT_GENFENCE_BREACH)
+      eventMask |= QMI_LOC_EVENT_MASK_GEOFENCE_BREACH_NOTIFICATION_V02;
+
+  if (mask & LOC_API_ADAPTER_BIT_BATCHED_GENFENCE_BREACH_REPORT)
+      eventMask |= QMI_LOC_EVENT_MASK_GEOFENCE_BATCH_BREACH_NOTIFICATION_V02;
+
+  if (mask & LOC_API_ADAPTER_BIT_PEDOMETER_CTRL)
+      eventMask |= QMI_LOC_EVENT_MASK_PEDOMETER_CONTROL_V02;
+
+  if (mask & LOC_API_ADAPTER_BIT_REPORT_GENFENCE_DWELL)
+      eventMask |= QMI_LOC_EVENT_MASK_GEOFENCE_BATCH_DWELL_NOTIFICATION_V02;
+
+  if (mask & LOC_API_ADAPTER_BIT_MOTION_CTRL)
+      eventMask |= QMI_LOC_EVENT_MASK_MOTION_DATA_CONTROL_V02;
+
+  if (mask & LOC_API_ADAPTER_BIT_REQUEST_WIFI_AP_DATA)
+      eventMask |= QMI_LOC_EVENT_MASK_INJECT_WIFI_AP_DATA_REQ_V02;
+
+  if(mask & LOC_API_ADAPTER_BIT_BATCH_FULL)
+      eventMask |= QMI_LOC_EVENT_MASK_BATCH_FULL_NOTIFICATION_V02;
+
+  if(mask & LOC_API_ADAPTER_BIT_BATCHED_POSITION_REPORT)
+      eventMask |= QMI_LOC_EVENT_MASK_LIVE_BATCHED_POSITION_REPORT_V02;
+
+  if(mask & LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT_REPORT)
+      eventMask |= QMI_LOC_EVENT_MASK_GNSS_MEASUREMENT_REPORT_V02;
+
+  if(mask & LOC_API_ADAPTER_BIT_GNSS_SV_POLYNOMIAL_REPORT)
+      eventMask |= QMI_LOC_EVENT_MASK_GNSS_SV_POLYNOMIAL_REPORT_V02;
+
+  // for GDT
+  if(mask & LOC_API_ADAPTER_BIT_GDT_UPLOAD_BEGIN_REQ)
+      eventMask |= QMI_LOC_EVENT_MASK_GDT_UPLOAD_BEGIN_REQ_V02;
+
+  if(mask & LOC_API_ADAPTER_BIT_GDT_UPLOAD_END_REQ)
+      eventMask |= QMI_LOC_EVENT_MASK_GDT_UPLOAD_END_REQ_V02;
+
+  if (mask & LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT)
+      eventMask |= QMI_LOC_EVENT_MASK_GNSS_MEASUREMENT_REPORT_V02;
+
+  if(mask & LOC_API_ADAPTER_BIT_REQUEST_TIMEZONE)
+      eventMask |= QMI_LOC_EVENT_MASK_GET_TIME_ZONE_REQ_V02;
+  return eventMask;
+}
+
+qmiLocLockEnumT_v02 LocApiV02 :: convertGpsLockMask(LOC_GPS_LOCK_MASK lockMask)
+{
+    /* GPS HAL uses power voting through GPS Lock mask.
+       When QCA1530 daemon is present two values are used: 101 and 103.*/
+    if ( 101 == lockMask || 103 == lockMask )
+    {
+        return (qmiLocLockEnumT_v02)lockMask;
+    }
+    if (isGpsLockAll(lockMask))
+        return eQMI_LOC_LOCK_ALL_V02;
+    if (isGpsLockMO(lockMask))
+        return eQMI_LOC_LOCK_MI_V02;
+    if (isGpsLockMT(lockMask))
+        return eQMI_LOC_LOCK_MT_V02;
+    if (isGpsLockNone(lockMask))
+        return eQMI_LOC_LOCK_NONE_V02;
+    return (qmiLocLockEnumT_v02)lockMask;
+}
+
+/* Convert error from loc_api_v02 to loc eng format*/
+enum loc_api_adapter_err LocApiV02 :: convertErr(
+  locClientStatusEnumType status)
+{
+  switch( status)
+  {
+    case eLOC_CLIENT_SUCCESS:
+      return LOC_API_ADAPTER_ERR_SUCCESS;
+
+    case eLOC_CLIENT_FAILURE_GENERAL:
+      return LOC_API_ADAPTER_ERR_GENERAL_FAILURE;
+
+    case eLOC_CLIENT_FAILURE_UNSUPPORTED:
+      return LOC_API_ADAPTER_ERR_UNSUPPORTED;
+
+    case eLOC_CLIENT_FAILURE_INVALID_PARAMETER:
+      return LOC_API_ADAPTER_ERR_INVALID_PARAMETER;
+
+    case eLOC_CLIENT_FAILURE_ENGINE_BUSY:
+      return LOC_API_ADAPTER_ERR_ENGINE_BUSY;
+
+    case eLOC_CLIENT_FAILURE_PHONE_OFFLINE:
+      return LOC_API_ADAPTER_ERR_PHONE_OFFLINE;
+
+    case eLOC_CLIENT_FAILURE_TIMEOUT:
+      return LOC_API_ADAPTER_ERR_TIMEOUT;
+
+    case eLOC_CLIENT_FAILURE_INVALID_HANDLE:
+      return LOC_API_ADAPTER_ERR_INVALID_HANDLE;
+
+    case eLOC_CLIENT_FAILURE_SERVICE_NOT_PRESENT:
+      return LOC_API_ADAPTER_ERR_SERVICE_NOT_PRESENT;
+
+    case eLOC_CLIENT_FAILURE_INTERNAL:
+      return LOC_API_ADAPTER_ERR_INTERNAL;
+
+    default:
+      return LOC_API_ADAPTER_ERR_FAILURE;
+  }
+}
+
+/* convert position report to loc eng format and send the converted
+   position to loc eng */
+
+void LocApiV02 :: reportPosition (
+  const qmiLocEventPositionReportIndMsgT_v02 *location_report_ptr)
+{
+    UlpLocation location;
+    LocPosTechMask tech_Mask = LOC_POS_TECH_MASK_DEFAULT;
+    LOC_LOGD("Reporting position from V2 Adapter\n");
+    memset(&location, 0, sizeof (UlpLocation));
+    location.size = sizeof(location);
+    GpsLocationExtended locationExtended;
+    memset(&locationExtended, 0, sizeof (GpsLocationExtended));
+    locationExtended.size = sizeof(locationExtended);
+    if( clock_gettime( CLOCK_BOOTTIME, &locationExtended.timeStamp.apTimeStamp)== 0 )
+    {
+       locationExtended.timeStamp.apTimeStampUncertaintyMs = (float)ap_timestamp_uncertainty;
+
+    }
+    else
+    {
+       locationExtended.timeStamp.apTimeStampUncertaintyMs = FLT_MAX;
+       LOC_LOGE("%s:%d Error in clock_gettime() ",__func__, __LINE__);
+    }
+    LOC_LOGD("%s:%d QMI_PosPacketTime  %ld (sec)  %ld (nsec)", __func__, __LINE__,
+                 locationExtended.timeStamp.apTimeStamp.tv_sec,
+                 locationExtended.timeStamp.apTimeStamp.tv_nsec);
+    // Process the position from final and intermediate reports
+
+    if( (location_report_ptr->sessionStatus == eQMI_LOC_SESS_STATUS_SUCCESS_V02) ||
+        (location_report_ptr->sessionStatus == eQMI_LOC_SESS_STATUS_IN_PROGRESS_V02)
+        )
+    {
+        // Latitude & Longitude
+        if( (1 == location_report_ptr->latitude_valid) &&
+            (1 == location_report_ptr->longitude_valid))
+        {
+            location.gpsLocation.flags  |= GPS_LOCATION_HAS_LAT_LONG;
+            location.gpsLocation.latitude  = location_report_ptr->latitude;
+            location.gpsLocation.longitude = location_report_ptr->longitude;
+
+            // Time stamp (UTC)
+            if(location_report_ptr->timestampUtc_valid == 1)
+            {
+                location.gpsLocation.timestamp = location_report_ptr->timestampUtc;
+            }
+
+            // Altitude
+            if(location_report_ptr->altitudeWrtEllipsoid_valid == 1  )
+            {
+                location.gpsLocation.flags  |= GPS_LOCATION_HAS_ALTITUDE;
+                location.gpsLocation.altitude = location_report_ptr->altitudeWrtEllipsoid;
+            }
+
+            // Speed
+            if(location_report_ptr->speedHorizontal_valid == 1)
+            {
+                location.gpsLocation.flags  |= GPS_LOCATION_HAS_SPEED;
+                location.gpsLocation.speed = location_report_ptr->speedHorizontal;
+            }
+
+            // Heading
+            if(location_report_ptr->heading_valid == 1)
+            {
+                location.gpsLocation.flags  |= GPS_LOCATION_HAS_BEARING;
+                location.gpsLocation.bearing = location_report_ptr->heading;
+            }
+
+            // Uncertainty (circular)
+            if (location_report_ptr->horUncCircular_valid) {
+                location.gpsLocation.flags |= GPS_LOCATION_HAS_ACCURACY;
+                location.gpsLocation.accuracy = location_report_ptr->horUncCircular;
+            } else if (location_report_ptr->horUncEllipseSemiMinor_valid &&
+                       location_report_ptr->horUncEllipseSemiMajor_valid) {
+                location.gpsLocation.flags |= GPS_LOCATION_HAS_ACCURACY;
+                location.gpsLocation.accuracy =
+                    sqrt((location_report_ptr->horUncEllipseSemiMinor *
+                          location_report_ptr->horUncEllipseSemiMinor) +
+                         (location_report_ptr->horUncEllipseSemiMajor *
+                          location_report_ptr->horUncEllipseSemiMajor));
+            }
+
+            // If horConfidence_valid is true, and horConfidence value is less than 68%
+            // then scale the accuracy value to 68% confidence.
+            if (location_report_ptr->horConfidence_valid)
+            {
+                scaleAccuracyTo68PercentConfidence(location_report_ptr->horConfidence,
+                                                   location.gpsLocation);
+            }
+
+            // Technology Mask
+            tech_Mask |= location_report_ptr->technologyMask;
+
+            //Mark the location source as from GNSS
+            location.gpsLocation.flags |= LOCATION_HAS_SOURCE_INFO;
+            location.position_source = ULP_LOCATION_IS_FROM_GNSS;
+            if (location_report_ptr->magneticDeviation_valid)
+            {
+                locationExtended.flags |= GPS_LOCATION_EXTENDED_HAS_MAG_DEV;
+                locationExtended.magneticDeviation = location_report_ptr->magneticDeviation;
+            }
+
+            if (location_report_ptr->DOP_valid)
+            {
+                locationExtended.flags |= GPS_LOCATION_EXTENDED_HAS_DOP;
+                locationExtended.pdop = location_report_ptr->DOP.PDOP;
+                locationExtended.hdop = location_report_ptr->DOP.HDOP;
+                locationExtended.vdop = location_report_ptr->DOP.VDOP;
+            }
+
+            if (location_report_ptr->altitudeWrtMeanSeaLevel_valid)
+            {
+                locationExtended.flags |= GPS_LOCATION_EXTENDED_HAS_ALTITUDE_MEAN_SEA_LEVEL;
+                locationExtended.altitudeMeanSeaLevel = location_report_ptr->altitudeWrtMeanSeaLevel;
+            }
+
+            if (location_report_ptr->vertUnc_valid)
+            {
+               locationExtended.flags |= GPS_LOCATION_EXTENDED_HAS_VERT_UNC;
+               locationExtended.vert_unc = location_report_ptr->vertUnc;
+            }
+
+            if (location_report_ptr->speedUnc_valid)
+            {
+               locationExtended.flags |= GPS_LOCATION_EXTENDED_HAS_SPEED_UNC;
+               locationExtended.speed_unc = location_report_ptr->speedUnc;
+            }
+            if (location_report_ptr->headingUnc_valid)
+            {
+               locationExtended.flags |= GPS_LOCATION_EXTENDED_HAS_BEARING_UNC;
+               locationExtended.bearing_unc = location_report_ptr->headingUnc;
+            }
+            if (location_report_ptr->horReliability_valid)
+            {
+               locationExtended.flags |= GPS_LOCATION_EXTENDED_HAS_HOR_RELIABILITY;
+               switch(location_report_ptr->horReliability)
+               {
+                  case eQMI_LOC_RELIABILITY_NOT_SET_V02 :
+                    locationExtended.horizontal_reliability = LOC_RELIABILITY_NOT_SET;
+                    break;
+                  case eQMI_LOC_RELIABILITY_VERY_LOW_V02 :
+                    locationExtended.horizontal_reliability = LOC_RELIABILITY_VERY_LOW;
+                    break;
+                  case eQMI_LOC_RELIABILITY_LOW_V02 :
+                    locationExtended.horizontal_reliability = LOC_RELIABILITY_LOW;
+                    break;
+                  case eQMI_LOC_RELIABILITY_MEDIUM_V02 :
+                    locationExtended.horizontal_reliability = LOC_RELIABILITY_MEDIUM;
+                    break;
+                  case eQMI_LOC_RELIABILITY_HIGH_V02 :
+                    locationExtended.horizontal_reliability = LOC_RELIABILITY_HIGH;
+                    break;
+                  default:
+                    locationExtended.horizontal_reliability = LOC_RELIABILITY_NOT_SET;
+                    break;
+               }
+            }
+            if (location_report_ptr->vertReliability_valid)
+            {
+               locationExtended.flags |= GPS_LOCATION_EXTENDED_HAS_VERT_RELIABILITY;
+               switch(location_report_ptr->vertReliability)
+               {
+                  case eQMI_LOC_RELIABILITY_NOT_SET_V02 :
+                    locationExtended.vertical_reliability = LOC_RELIABILITY_NOT_SET;
+                    break;
+                  case eQMI_LOC_RELIABILITY_VERY_LOW_V02 :
+                    locationExtended.vertical_reliability = LOC_RELIABILITY_VERY_LOW;
+                    break;
+                  case eQMI_LOC_RELIABILITY_LOW_V02 :
+                    locationExtended.vertical_reliability = LOC_RELIABILITY_LOW;
+                    break;
+                  case eQMI_LOC_RELIABILITY_MEDIUM_V02 :
+                    locationExtended.vertical_reliability = LOC_RELIABILITY_MEDIUM;
+                    break;
+                  case eQMI_LOC_RELIABILITY_HIGH_V02 :
+                    locationExtended.vertical_reliability = LOC_RELIABILITY_HIGH;
+                    break;
+                  default:
+                    locationExtended.vertical_reliability = LOC_RELIABILITY_NOT_SET;
+                    break;
+               }
+            }
+            if (location_report_ptr->horUncEllipseSemiMajor_valid)
+            {
+                locationExtended.flags |= GPS_LOCATION_EXTENDED_HAS_HOR_ELIP_UNC_MAJOR;
+                locationExtended.horUncEllipseSemiMajor = location_report_ptr->horUncEllipseSemiMajor;
+            }
+            if (location_report_ptr->horUncEllipseSemiMinor_valid)
+            {
+                locationExtended.flags |= GPS_LOCATION_EXTENDED_HAS_HOR_ELIP_UNC_MINOR;
+                locationExtended.horUncEllipseSemiMinor = location_report_ptr->horUncEllipseSemiMinor;
+            }
+            if (location_report_ptr->horUncEllipseOrientAzimuth_valid)
+            {
+                locationExtended.flags |= GPS_LOCATION_EXTENDED_HAS_HOR_ELIP_UNC_AZIMUTH;
+                locationExtended.horUncEllipseOrientAzimuth = location_report_ptr->horUncEllipseOrientAzimuth;
+            }
+
+            if((0 == location_report_ptr->latitude) &&
+               (0 == location_report_ptr->latitude) &&
+               (1 == location_report_ptr->horReliability_valid) &&
+               (eQMI_LOC_RELIABILITY_NOT_SET_V02 ==
+                   location_report_ptr->horReliability))
+            {
+                /*Only BlankNMEA sentence needs to be processed and sent, position
+                 * shall not be sent to framework if both lat,long is 0 & horReliability
+                 * not set, hence we report session failure status */
+                LocApiBase::reportPosition( location,
+                                locationExtended,
+                                (void*)location_report_ptr,
+                                LOC_SESS_FAILURE,
+                                tech_Mask);
+            }
+            else
+            {
+            LocApiBase::reportPosition( location,
+                            locationExtended,
+                            (void*)location_report_ptr,
+                            (location_report_ptr->sessionStatus
+                             == eQMI_LOC_SESS_STATUS_IN_PROGRESS_V02 ?
+                             LOC_SESS_INTERMEDIATE : LOC_SESS_SUCCESS),
+                            tech_Mask);
+        }
+    }
+    }
+    else
+    {
+        LocApiBase::reportPosition(location,
+                                   locationExtended,
+                                   NULL,
+                                   LOC_SESS_FAILURE);
+
+        LOC_LOGD("%s:%d]: Ignoring position report with sess status = %d, "
+                      "fix id = %u\n", __func__, __LINE__,
+                      location_report_ptr->sessionStatus,
+                      location_report_ptr->fixId );
+    }
+}
+
+/* convert satellite report to loc eng format and  send the converted
+   report to loc eng */
+void  LocApiV02 :: reportSv (
+  const qmiLocEventGnssSvInfoIndMsgT_v02 *gnss_report_ptr)
+{
+  GnssSvStatus      SvStatus;
+  GpsLocationExtended locationExtended;
+  int              num_svs_max, i;
+  const qmiLocSvInfoStructT_v02 *sv_info_ptr;
+
+  LOC_LOGV ("%s:%d]: num of sv = %d, validity = %d, altitude assumed = %u \n",
+            __func__, __LINE__, gnss_report_ptr->svList_len,
+            gnss_report_ptr->svList_valid,
+            gnss_report_ptr->altitudeAssumed);
+
+  num_svs_max = 0;
+  memset (&SvStatus, 0, sizeof (GnssSvStatus));
+  memset(&locationExtended, 0, sizeof (GpsLocationExtended));
+
+  SvStatus.size = sizeof(GnssSvStatus);
+  locationExtended.size = sizeof(locationExtended);
+  if(gnss_report_ptr->svList_valid == 1)
+  {
+    num_svs_max = gnss_report_ptr->svList_len;
+    if(num_svs_max > GNSS_MAX_SVS)
+    {
+      num_svs_max = GNSS_MAX_SVS;
+    }
+    SvStatus.num_svs = 0;
+    for(i = 0; i < num_svs_max; i++)
+    {
+      sv_info_ptr = &(gnss_report_ptr->svList[i]);
+      if((sv_info_ptr->validMask & QMI_LOC_SV_INFO_MASK_VALID_SYSTEM_V02) &&
+         (sv_info_ptr->validMask & QMI_LOC_SV_INFO_MASK_VALID_GNSS_SVID_V02)
+         && (sv_info_ptr->gnssSvId != 0 ))
+      {
+        GnssSvFlags flags = GNSS_SV_FLAGS_NONE;
+
+        SvStatus.gnss_sv_list[SvStatus.num_svs].size = sizeof(GnssSvInfo);
+        switch (sv_info_ptr->system)
+        {
+          case eQMI_LOC_SV_SYSTEM_GPS_V02:
+            SvStatus.gnss_sv_list[SvStatus.num_svs].svid = sv_info_ptr->gnssSvId;
+            SvStatus.gnss_sv_list[SvStatus.num_svs].constellation = GNSS_CONSTELLATION_GPS;
+            break;
+
+          case eQMI_LOC_SV_SYSTEM_GALILEO_V02:
+            SvStatus.gnss_sv_list[SvStatus.num_svs].svid = sv_info_ptr->gnssSvId-300;
+            SvStatus.gnss_sv_list[SvStatus.num_svs].constellation = GNSS_CONSTELLATION_GALILEO;
+            break;
+
+          case eQMI_LOC_SV_SYSTEM_SBAS_V02:
+            SvStatus.gnss_sv_list[SvStatus.num_svs].svid = sv_info_ptr->gnssSvId;
+            SvStatus.gnss_sv_list[SvStatus.num_svs].constellation = GNSS_CONSTELLATION_SBAS;
+            break;
+
+          case eQMI_LOC_SV_SYSTEM_GLONASS_V02:
+            SvStatus.gnss_sv_list[SvStatus.num_svs].svid = sv_info_ptr->gnssSvId;
+            SvStatus.gnss_sv_list[SvStatus.num_svs].constellation = GNSS_CONSTELLATION_GLONASS;
+            break;
+
+          case eQMI_LOC_SV_SYSTEM_BDS_V02:
+            SvStatus.gnss_sv_list[SvStatus.num_svs].svid = sv_info_ptr->gnssSvId - 200;
+            SvStatus.gnss_sv_list[SvStatus.num_svs].constellation = GNSS_CONSTELLATION_BEIDOU;
+            break;
+
+          case eQMI_LOC_SV_SYSTEM_QZSS_V02:
+            SvStatus.gnss_sv_list[SvStatus.num_svs].svid = sv_info_ptr->gnssSvId;
+            SvStatus.gnss_sv_list[SvStatus.num_svs].constellation = GNSS_CONSTELLATION_QZSS;
+            break;
+
+          case eQMI_LOC_SV_SYSTEM_COMPASS_V02:
+          default:
+            SvStatus.gnss_sv_list[SvStatus.num_svs].svid = sv_info_ptr->gnssSvId;
+            SvStatus.gnss_sv_list[SvStatus.num_svs].constellation = GNSS_CONSTELLATION_UNKNOWN;
+            break;
+        }
+
+        if (sv_info_ptr->validMask & QMI_LOC_SV_INFO_MASK_VALID_SNR_V02)
+        {
+          SvStatus.gnss_sv_list[SvStatus.num_svs].c_n0_dbhz = sv_info_ptr->snr;
+        }
+
+        if (sv_info_ptr->validMask & QMI_LOC_SV_INFO_MASK_VALID_ELEVATION_V02)
+        {
+            SvStatus.gnss_sv_list[SvStatus.num_svs].elevation = sv_info_ptr->elevation;
+        }
+
+        if (sv_info_ptr->validMask & QMI_LOC_SV_INFO_MASK_VALID_AZIMUTH_V02)
+        {
+          SvStatus.gnss_sv_list[SvStatus.num_svs].azimuth = sv_info_ptr->azimuth;
+        }
+
+        if (sv_info_ptr->validMask &
+             QMI_LOC_SV_INFO_MASK_VALID_SVINFO_MASK_V02)
+        {
+          if (sv_info_ptr->svInfoMask &
+               QMI_LOC_SVINFO_MASK_HAS_EPHEMERIS_V02)
+          {
+              flags |= GNSS_SV_FLAGS_HAS_EPHEMERIS_DATA;
+          }
+          if (sv_info_ptr->svInfoMask &
+             QMI_LOC_SVINFO_MASK_HAS_ALMANAC_V02)
+          {
+              flags |= GNSS_SV_FLAGS_HAS_ALMANAC_DATA;
+          }
+        }
+
+        /* Even if modem stops tracking some SV’s, it reports them in the measurement
+           report with Ephermeris/Alamanac data with 0 SNR. So in addition to check for
+           availability of Alm or Eph data, also check for SNR > 0 to indicate SV is
+           used in fix. */
+        if ((sv_info_ptr->validMask &
+             QMI_LOC_SV_INFO_MASK_VALID_PROCESS_STATUS_V02)
+             &&
+             (sv_info_ptr->svStatus == eQMI_LOC_SV_STATUS_TRACK_V02)
+             &&
+             (sv_info_ptr->snr > 0)
+             &&
+             ((flags & GNSS_SV_FLAGS_HAS_EPHEMERIS_DATA)
+               ||
+              (flags & GNSS_SV_FLAGS_HAS_ALMANAC_DATA)))
+        {
+            flags |= GNSS_SV_FLAGS_USED_IN_FIX;
+        }
+
+        SvStatus.gnss_sv_list[SvStatus.num_svs].flags = flags;
+
+        SvStatus.num_svs++;
+      }
+    }
+  }
+
+  if (SvStatus.num_svs >= 0)
+  {
+    LOC_LOGV ("%s:%d]: firing SV callback\n", __func__, __LINE__);
+    LocApiBase::reportSv(SvStatus,
+                         locationExtended,
+                         (void*)gnss_report_ptr);
+  }
+}
+
+/* convert satellite measurementreport to loc eng format and  send the converted
+   report to loc eng */
+void  LocApiV02 :: reportSvMeasurement (
+  const qmiLocEventGnssSvMeasInfoIndMsgT_v02 *gnss_raw_measurement_ptr)
+{
+  GnssSvMeasurementSet                 svMeasurementSet;
+  memset(&svMeasurementSet, 0, sizeof(GnssSvMeasurementSet));
+  svMeasurementSet.size = sizeof(svMeasurementSet);
+
+  if( clock_gettime( CLOCK_BOOTTIME, &svMeasurementSet.timeStamp.apTimeStamp)== 0 )
+  {
+    svMeasurementSet.timeStamp.apTimeStampUncertaintyMs = (float)ap_timestamp_uncertainty;
+  }
+  else
+  {
+    svMeasurementSet.timeStamp.apTimeStampUncertaintyMs = FLT_MAX;
+    LOC_LOGE("%s:%d Error in clock_gettime() ",__func__, __LINE__);
+  }
+  LOC_LOGD("%s:%d QMI_MeasPacketTime  %ld (sec)  %ld (nsec)",__func__,__LINE__,
+            svMeasurementSet.timeStamp.apTimeStamp.tv_sec,
+            svMeasurementSet.timeStamp.apTimeStamp.tv_nsec);
+
+  LOC_LOGI("[SvMeas] SeqNum: %d, MaxMsgNum: %d, MeasValid: %d, #of SV: %d\n",
+           gnss_raw_measurement_ptr->seqNum,
+           gnss_raw_measurement_ptr->maxMessageNum,
+           gnss_raw_measurement_ptr->svMeasurement_valid,
+           (gnss_raw_measurement_ptr->svMeasurement_valid)?
+           gnss_raw_measurement_ptr->svMeasurement_len : 0);
+
+  svMeasurementSet.seqNum           = gnss_raw_measurement_ptr->seqNum;
+  svMeasurementSet.maxMessageNum    = gnss_raw_measurement_ptr->maxMessageNum;
+
+  if(1 == gnss_raw_measurement_ptr->rcvrClockFrequencyInfo_valid)
+  {
+    qmiLocRcvrClockFrequencyInfoStructT_v02* rcvClockFreqInfo =
+      (qmiLocRcvrClockFrequencyInfoStructT_v02*) &gnss_raw_measurement_ptr->rcvrClockFrequencyInfo;
+
+    svMeasurementSet.clockFreq.size         = sizeof(Gnss_LocRcvrClockFrequencyInfoStructType);
+    svMeasurementSet.clockFreqValid         = gnss_raw_measurement_ptr->rcvrClockFrequencyInfo_valid;
+    svMeasurementSet.clockFreq.clockDrift   =
+        gnss_raw_measurement_ptr->rcvrClockFrequencyInfo.clockDrift;
+    svMeasurementSet.clockFreq.clockDriftUnc =
+        gnss_raw_measurement_ptr->rcvrClockFrequencyInfo.clockDriftUnc;
+    svMeasurementSet.clockFreq.sourceOfFreq = (Gnss_LocSourceofFreqEnumType)
+        gnss_raw_measurement_ptr->rcvrClockFrequencyInfo.sourceOfFreq;
+
+    LOC_LOGV("FreqInfo:: Drift: %f, DriftUnc: %f",
+             svMeasurementSet.clockFreq.clockDrift,
+             svMeasurementSet.clockFreq.clockDriftUnc);
+  }
+
+  if((1 == gnss_raw_measurement_ptr->leapSecondInfo_valid) &&
+     (0 == gnss_raw_measurement_ptr->leapSecondInfo.leapSecUnc) )
+  {
+    qmiLocLeapSecondInfoStructT_v02* leapSecond =
+      (qmiLocLeapSecondInfoStructT_v02*)&gnss_raw_measurement_ptr->leapSecondInfo;
+
+    svMeasurementSet.leapSec.size       = sizeof(Gnss_LeapSecondInfoStructType);
+    svMeasurementSet.leapSecValid       = (bool)gnss_raw_measurement_ptr->leapSecondInfo_valid;
+    svMeasurementSet.leapSec.leapSec    = gnss_raw_measurement_ptr->leapSecondInfo.leapSec;
+    svMeasurementSet.leapSec.leapSecUnc = gnss_raw_measurement_ptr->leapSecondInfo.leapSecUnc;
+    LOC_LOGV("leapSecondInfo:: leapSec: %d, leapSecUnc: %d",
+      svMeasurementSet.leapSec.leapSec, svMeasurementSet.leapSec.leapSecUnc);
+  }
+
+  if(1 == gnss_raw_measurement_ptr->gpsGloInterSystemBias_valid)
+  {
+    qmiLocInterSystemBiasStructT_v02* interSystemBias =
+      (qmiLocInterSystemBiasStructT_v02*)&gnss_raw_measurement_ptr->gpsGloInterSystemBias;
+
+    getInterSystemTimeBias("gpsGloInterSystemBias",
+                           svMeasurementSet.gpsGloInterSystemBias, interSystemBias);
+  }
+
+  if(1 == gnss_raw_measurement_ptr->gpsBdsInterSystemBias_valid)
+  {
+    qmiLocInterSystemBiasStructT_v02* interSystemBias =
+      (qmiLocInterSystemBiasStructT_v02*)&gnss_raw_measurement_ptr->gpsBdsInterSystemBias;
+
+    getInterSystemTimeBias("gpsBdsInterSystemBias",
+                           svMeasurementSet.gpsBdsInterSystemBias, interSystemBias);
+  }
+
+  if(1 == gnss_raw_measurement_ptr->gpsGalInterSystemBias_valid)
+  {
+    qmiLocInterSystemBiasStructT_v02* interSystemBias =
+      (qmiLocInterSystemBiasStructT_v02*)&gnss_raw_measurement_ptr->gpsGalInterSystemBias;
+
+    getInterSystemTimeBias("gpsGalInterSystemBias",
+                           svMeasurementSet.gpsGalInterSystemBias, interSystemBias);
+  }
+
+  if(1 == gnss_raw_measurement_ptr->bdsGloInterSystemBias_valid)
+  {
+    qmiLocInterSystemBiasStructT_v02* interSystemBias =
+      (qmiLocInterSystemBiasStructT_v02*)&gnss_raw_measurement_ptr->bdsGloInterSystemBias;
+
+    getInterSystemTimeBias("bdsGloInterSystemBias",
+                           svMeasurementSet.bdsGloInterSystemBias, interSystemBias);
+  }
+
+  if(1 == gnss_raw_measurement_ptr->galGloInterSystemBias_valid)
+  {
+    qmiLocInterSystemBiasStructT_v02* interSystemBias =
+      (qmiLocInterSystemBiasStructT_v02*)&gnss_raw_measurement_ptr->galGloInterSystemBias;
+
+    getInterSystemTimeBias("galGloInterSystemBias",
+                           svMeasurementSet.galGloInterSystemBias, interSystemBias);
+  }
+
+  if(1 == gnss_raw_measurement_ptr->galBdsInterSystemBias_valid)
+  {
+    qmiLocInterSystemBiasStructT_v02* interSystemBias =
+      (qmiLocInterSystemBiasStructT_v02*)&gnss_raw_measurement_ptr->galBdsInterSystemBias;
+
+    getInterSystemTimeBias("galBdsInterSystemBias",
+                           svMeasurementSet.galBdsInterSystemBias,interSystemBias);
+  }
+
+  svMeasurementSet.gnssMeas.size  = sizeof(Gnss_SVMeasurementStructType);
+  svMeasurementSet.gnssMeas.system  = (Gnss_LocSvSystemEnumType)gnss_raw_measurement_ptr->system;
+
+  if(1 == gnss_raw_measurement_ptr->systemTime_valid)
+  {
+    svMeasurementSet.gnssMeas.isSystemTimeValid = gnss_raw_measurement_ptr->systemTime_valid;
+    svMeasurementSet.gnssMeas.systemTime.size        = sizeof(Gnss_LocSystemTimeStructType);
+
+    svMeasurementSet.gnssMeas.systemTime.systemWeek  =
+        gnss_raw_measurement_ptr->systemTime.systemWeek;
+
+    svMeasurementSet.gnssMeas.systemTime.systemMsec  =
+        gnss_raw_measurement_ptr->systemTime.systemMsec;
+
+    svMeasurementSet.gnssMeas.systemTime.systemClkTimeBias  =
+        gnss_raw_measurement_ptr->systemTime.systemClkTimeBias;
+
+    svMeasurementSet.gnssMeas.systemTime.systemClkTimeUncMs =
+        gnss_raw_measurement_ptr->systemTime.systemClkTimeUncMs;
+  }
+
+  if(1 == gnss_raw_measurement_ptr->gloTime_valid)
+  {
+    svMeasurementSet.gnssMeas.isGloTime_valid     = gnss_raw_measurement_ptr->gloTime_valid;
+    svMeasurementSet.gnssMeas.gloTime.size        = sizeof(Gnss_LocGloTimeStructType);
+
+    svMeasurementSet.gnssMeas.gloTime.gloDays     = gnss_raw_measurement_ptr->gloTime.gloDays;
+    svMeasurementSet.gnssMeas.gloTime.gloFourYear = gnss_raw_measurement_ptr->gloTime.gloFourYear;
+    svMeasurementSet.gnssMeas.gloTime.gloMsec     = gnss_raw_measurement_ptr->gloTime.gloMsec;
+    svMeasurementSet.gnssMeas.gloTime.gloClkTimeBias    = gnss_raw_measurement_ptr->gloTime.gloClkTimeBias;
+    svMeasurementSet.gnssMeas.gloTime.gloClkTimeUncMs   = gnss_raw_measurement_ptr->gloTime.gloClkTimeUncMs;
+  }
+
+  if(1 == gnss_raw_measurement_ptr->systemTimeExt_valid)
+  {
+    svMeasurementSet.gnssMeas.isSystemTimeExt_valid  = gnss_raw_measurement_ptr->systemTimeExt_valid;
+    svMeasurementSet.gnssMeas.systemTimeExt.size     = sizeof(Gnss_LocGnssTimeExtStructType);
+
+    svMeasurementSet.gnssMeas.systemTimeExt.refFCount   = gnss_raw_measurement_ptr->systemTimeExt.refFCount;
+
+    svMeasurementSet.gnssMeas.systemTimeExt.systemRtc_valid  =
+      gnss_raw_measurement_ptr->systemTimeExt.systemRtc_valid;
+
+    svMeasurementSet.gnssMeas.systemTimeExt.systemRtcMs =
+      gnss_raw_measurement_ptr->systemTimeExt.systemRtcMs;
+
+    svMeasurementSet.gnssMeas.systemTimeExt.sourceOfTime  =
+      gnss_raw_measurement_ptr->systemTimeExt.sourceOfTime;
+
+  }
+
+
+  if(1 == gnss_raw_measurement_ptr->svMeasurement_valid)
+  {
+
+    svMeasurementSet.gnssMeas.numSvs = gnss_raw_measurement_ptr->svMeasurement_len;
+    svMeasurementSet.gnssMeasValid   = gnss_raw_measurement_ptr->svMeasurement_valid;
+
+    if(gnss_raw_measurement_ptr->svMeasurement_len > GNSS_LOC_SV_MEAS_LIST_MAX_SIZE)
+    {
+      //This should not happen normally, anycase limit to Max List Size
+      svMeasurementSet.gnssMeas.numSvs = GNSS_LOC_SV_MEAS_LIST_MAX_SIZE;
+    }
+    svMeasurementSet.gnssMeas.numSvs = gnss_raw_measurement_ptr->svMeasurement_len;
+    svMeasurementSet.gnssMeasValid   = gnss_raw_measurement_ptr->svMeasurement_valid;
+
+    uint32_t i = 0, cnt=0;
+    for(i=0;i<gnss_raw_measurement_ptr->svMeasurement_len;i++)
+    {
+      svMeasurementSet.gnssMeas.svMeasurement[i].size = sizeof(Gnss_SVMeasurementStructType);
+
+      if((0 != gnss_raw_measurement_ptr->svMeasurement[i].gnssSvId) &&
+         (0 != gnss_raw_measurement_ptr->svMeasurement[i].measurementStatus))
+      {
+        svMeasurementSet.gnssMeas.svMeasurement[i].gnssSvId =
+                 gnss_raw_measurement_ptr->svMeasurement[i].gnssSvId;
+
+        svMeasurementSet.gnssMeas.svMeasurement[i].gloFrequency =
+                 gnss_raw_measurement_ptr->svMeasurement[i].gloFrequency;
+
+        if(gnss_raw_measurement_ptr->svMeasurement[i].validMask & QMI_LOC_SV_LOSSOFLOCK_VALID_V02)
+        {
+          svMeasurementSet.gnssMeas.svMeasurement[i].lossOfLock = (bool)
+                 gnss_raw_measurement_ptr->svMeasurement[i].lossOfLock;
+        }
+
+        svMeasurementSet.gnssMeas.svMeasurement[i].svStatus = (Gnss_LocSvSearchStatusEnumT)
+                         gnss_raw_measurement_ptr->svMeasurement[i].svStatus;
+
+        if(gnss_raw_measurement_ptr->svMeasurement[i].validMask & QMI_LOC_SV_HEALTH_VALID_V02)
+        {
+          svMeasurementSet.gnssMeas.svMeasurement[i].healthStatus_valid = 1;
+          svMeasurementSet.gnssMeas.svMeasurement[i].healthStatus = (uint8_t)gnss_raw_measurement_ptr->svMeasurement[i].healthStatus;
+        }
+        svMeasurementSet.gnssMeas.svMeasurement[i].svInfoMask = (Gnss_LocSvInfoMaskT)
+                 gnss_raw_measurement_ptr->svMeasurement[i].svInfoMask;
+
+        svMeasurementSet.gnssMeas.svMeasurement[i].CNo =
+                 gnss_raw_measurement_ptr->svMeasurement[i].CNo;
+
+        svMeasurementSet.gnssMeas.svMeasurement[i].gloRfLoss =
+                 gnss_raw_measurement_ptr->svMeasurement[i].gloRfLoss;
+
+        svMeasurementSet.gnssMeas.svMeasurement[i].measLatency =
+                 gnss_raw_measurement_ptr->svMeasurement[i].measLatency;
+
+        /*SVTimeSpeed*/
+        svMeasurementSet.gnssMeas.svMeasurement[i].svTimeSpeed.size = sizeof(Gnss_LocSVTimeSpeedStructType);
+        svMeasurementSet.gnssMeas.svMeasurement[i].svTimeSpeed.svMs =
+                 gnss_raw_measurement_ptr->svMeasurement[i].svTimeSpeed.svTimeMs;
+        svMeasurementSet.gnssMeas.svMeasurement[i].svTimeSpeed.svSubMs =
+                 gnss_raw_measurement_ptr->svMeasurement[i].svTimeSpeed.svTimeSubMs;
+        svMeasurementSet.gnssMeas.svMeasurement[i].svTimeSpeed.svTimeUncMs =
+                 gnss_raw_measurement_ptr->svMeasurement[i].svTimeSpeed.svTimeUncMs;
+        svMeasurementSet.gnssMeas.svMeasurement[i].svTimeSpeed.dopplerShift =
+                 gnss_raw_measurement_ptr->svMeasurement[i].svTimeSpeed.dopplerShift;
+        svMeasurementSet.gnssMeas.svMeasurement[i].svTimeSpeed.dopplerShiftUnc=
+                 gnss_raw_measurement_ptr->svMeasurement[i].svTimeSpeed.dopplerShiftUnc;
+
+        svMeasurementSet.gnssMeas.svMeasurement[i].measurementStatus =
+                 (uint32_t)gnss_raw_measurement_ptr->svMeasurement[i].measurementStatus;
+
+        if(gnss_raw_measurement_ptr->svMeasurement[i].validMask & QMI_LOC_SV_MULTIPATH_EST_VALID_V02)
+        {
+          svMeasurementSet.gnssMeas.svMeasurement[i].multipathEstValid = 1;
+          svMeasurementSet.gnssMeas.svMeasurement[i].multipathEstimate =
+            gnss_raw_measurement_ptr->svMeasurement[i].multipathEstimate;
+        }
+
+        if(gnss_raw_measurement_ptr->svMeasurement[i].validMask & QMI_LOC_SV_FINE_SPEED_VALID_V02)
+        {
+          svMeasurementSet.gnssMeas.svMeasurement[i].fineSpeedValid = 1;
+
+          svMeasurementSet.gnssMeas.svMeasurement[i].fineSpeed  =
+            gnss_raw_measurement_ptr->svMeasurement[i].fineSpeed;
+        }
+        if(gnss_raw_measurement_ptr->svMeasurement[i].validMask & QMI_LOC_SV_FINE_SPEED_UNC_VALID_V02)
+        {
+           svMeasurementSet.gnssMeas.svMeasurement[i].fineSpeedUncValid = 1;
+
+          svMeasurementSet.gnssMeas.svMeasurement[i].fineSpeedUnc =
+            gnss_raw_measurement_ptr->svMeasurement[i].fineSpeedUnc;
+        }
+        if(gnss_raw_measurement_ptr->svMeasurement[i].validMask & QMI_LOC_SV_CARRIER_PHASE_VALID_V02)
+        {
+          svMeasurementSet.gnssMeas.svMeasurement[i].carrierPhaseValid = 1;
+
+          svMeasurementSet.gnssMeas.svMeasurement[i].carrierPhase =
+            gnss_raw_measurement_ptr->svMeasurement[i].carrierPhase;
+        }
+        if(gnss_raw_measurement_ptr->svMeasurement[i].validMask & QMI_LOC_SV_SV_DIRECTION_VALID_V02)
+        {
+          svMeasurementSet.gnssMeas.svMeasurement[i].svDirectionValid = 1;
+
+          svMeasurementSet.gnssMeas.svMeasurement[i].svElevation =
+            gnss_raw_measurement_ptr->svMeasurement[i].svElevation;
+          svMeasurementSet.gnssMeas.svMeasurement[i].svAzimuth =
+            gnss_raw_measurement_ptr->svMeasurement[i].svAzimuth;
+        }
+        if(gnss_raw_measurement_ptr->svMeasurement[i].validMask & QMI_LOC_SV_CYCLESLIP_COUNT_VALID_V02)
+        {
+          svMeasurementSet.gnssMeas.svMeasurement[i].cycleSlipCountValid = 1;
+          svMeasurementSet.gnssMeas.svMeasurement[i].cycleSlipCount =
+            gnss_raw_measurement_ptr->svMeasurement[i].cycleSlipCount;
+        }
+
+        cnt++;
+
+      }
+
+      svMeasurementSet.gnssMeas.numSvs = cnt;   /*set the measurement length to the actual SVId's filled in the array*/
+
+    }
+
+    if(gnss_raw_measurement_ptr->svMeasurement_len != cnt)
+    {
+      LOC_LOGW("[SV_MEAS_QMI] #of SV in QMI: %d, Valid SV-id Count: %d",
+                 gnss_raw_measurement_ptr->svMeasurement_len,cnt );
+    }
+
+  } //if svClockMeasurement_valid
+  else
+  {
+    LOC_LOGV("%s] [SV_MEAS] SV Measurement Not Valid", __func__);
+  }
+  //Report SV measurement irrespective of #of SVs for APDR
+  LocApiBase::reportSvMeasurement(svMeasurementSet);
+}
+
+/* convert satellite polynomial to loc eng format and  send the converted
+   report to loc eng */
+void  LocApiV02 :: reportSvPolynomial (
+  const qmiLocEventGnssSvPolyIndMsgT_v02 *gnss_sv_poly_ptr)
+{
+  GnssSvPolynomial  svPolynomial;
+
+  memset(&svPolynomial, 0, sizeof(GnssSvPolynomial));
+  svPolynomial.size = sizeof(GnssSvPolynomial);
+  svPolynomial.is_valid = 0;
+
+  if(0 != gnss_sv_poly_ptr->gnssSvId)
+  {
+    svPolynomial.gnssSvId       = gnss_sv_poly_ptr->gnssSvId;
+    svPolynomial.T0             = gnss_sv_poly_ptr->T0;
+    svPolynomial.svPolyFlags    = gnss_sv_poly_ptr->svPolyFlags;
+
+    if(1 == gnss_sv_poly_ptr->gloFrequency_valid)
+    {
+      svPolynomial.is_valid  |= ULP_GNSS_SV_POLY_BIT_GLO_FREQ;
+      svPolynomial.freqNum   = gnss_sv_poly_ptr->gloFrequency;
+    }
+    if(1 == gnss_sv_poly_ptr->IODE_valid)
+    {
+      svPolynomial.is_valid  |= ULP_GNSS_SV_POLY_BIT_IODE;
+      svPolynomial.iode       = gnss_sv_poly_ptr->IODE;
+     }
+
+    if(1 == gnss_sv_poly_ptr->svPosUnc_valid)
+    {
+      svPolynomial.is_valid |= ULP_GNSS_SV_POLY_BIT_SV_POSUNC;
+      svPolynomial.svPosUnc = gnss_sv_poly_ptr->svPosUnc;
+    }
+
+    if(1 == gnss_sv_poly_ptr->svPolyFlagValid)
+    {
+      svPolynomial.is_valid |= ULP_GNSS_SV_POLY_BIT_FLAG;
+      svPolynomial.svPolyFlags  = gnss_sv_poly_ptr->svPolyFlags;
+    }
+
+    if(1 == gnss_sv_poly_ptr->polyCoeffXYZ0_valid)
+    {
+      svPolynomial.is_valid |= ULP_GNSS_SV_POLY_BIT_POLYCOEFF_XYZ0;
+      for(int i=0;i<GNSS_SV_POLY_XYZ_0_TH_ORDER_COEFF_MAX_SIZE;i++)
+      {
+        svPolynomial.polyCoeffXYZ0[i] = gnss_sv_poly_ptr->polyCoeffXYZ0[i];
+      }
+    }
+
+    if(1 == gnss_sv_poly_ptr->polyCoefXYZN_valid)
+    {
+      svPolynomial.is_valid |= ULP_GNSS_SV_POLY_BIT_POLYCOEFF_XYZN;
+      for(int i=0;i<GNSS_SV_POLY_XYZ_N_TH_ORDER_COEFF_MAX_SIZE;i++)
+      {
+        svPolynomial.polyCoefXYZN[i] = gnss_sv_poly_ptr->polyCoefXYZN[i];
+      }
+    }
+
+    if(1 == gnss_sv_poly_ptr->polyCoefClockBias_valid)
+    {
+
+      svPolynomial.is_valid |= ULP_GNSS_SV_POLY_BIT_POLYCOEFF_OTHER;
+      for(int i=0;i<GNSS_SV_POLY_SV_CLKBIAS_COEFF_MAX_SIZE;i++)
+      {
+        svPolynomial.polyCoefOther[i] = gnss_sv_poly_ptr->polyCoefClockBias[i];
+      }
+    }
+
+    if(1 == gnss_sv_poly_ptr->ionoDot_valid)
+    {
+      svPolynomial.is_valid |= ULP_GNSS_SV_POLY_BIT_IONODOT;
+      svPolynomial.ionoDot = gnss_sv_poly_ptr->ionoDot;
+    }
+    if(1 == gnss_sv_poly_ptr->ionoDelay_valid)
+    {
+      svPolynomial.is_valid |= ULP_GNSS_SV_POLY_BIT_IONODELAY;
+      svPolynomial.ionoDelay = gnss_sv_poly_ptr->ionoDelay;
+    }
+
+    if(1 == gnss_sv_poly_ptr->sbasIonoDot_valid)
+    {
+      svPolynomial.is_valid |= ULP_GNSS_SV_POLY_BIT_SBAS_IONODOT;
+      svPolynomial.sbasIonoDot = gnss_sv_poly_ptr->sbasIonoDot;
+    }
+    if(1 == gnss_sv_poly_ptr->sbasIonoDelay_valid)
+    {
+      svPolynomial.is_valid |= ULP_GNSS_SV_POLY_BIT_SBAS_IONODELAY;
+      svPolynomial.sbasIonoDelay = gnss_sv_poly_ptr->sbasIonoDelay;
+    }
+    if(1 == gnss_sv_poly_ptr->tropoDelay_valid)
+    {
+      svPolynomial.is_valid |= ULP_GNSS_SV_POLY_BIT_TROPODELAY;
+      svPolynomial.tropoDelay = gnss_sv_poly_ptr->tropoDelay;
+    }
+    if(1 == gnss_sv_poly_ptr->elevation_valid)
+    {
+      svPolynomial.is_valid |= ULP_GNSS_SV_POLY_BIT_ELEVATION;
+      svPolynomial.elevation = gnss_sv_poly_ptr->elevation;
+    }
+    if(1 == gnss_sv_poly_ptr->elevationDot_valid)
+    {
+      svPolynomial.is_valid |= ULP_GNSS_SV_POLY_BIT_ELEVATIONDOT;
+      svPolynomial.elevationDot = gnss_sv_poly_ptr->elevationDot;
+    }
+    if(1 == gnss_sv_poly_ptr->elenationUnc_valid)
+    {
+      svPolynomial.is_valid |= ULP_GNSS_SV_POLY_BIT_ELEVATIONUNC;
+      svPolynomial.elevationUnc = gnss_sv_poly_ptr->elenationUnc;
+    }
+    if(1 == gnss_sv_poly_ptr->velCoef_valid)
+    {
+      svPolynomial.is_valid |= ULP_GNSS_SV_POLY_BIT_VELO_COEFF;
+      for(int i=0;i<GNSS_SV_POLY_VELOCITY_COEF_MAX_SIZE;i++)
+      {
+        svPolynomial.velCoef[i] = gnss_sv_poly_ptr->velCoef[i];
+      }
+    }
+    if(1 == gnss_sv_poly_ptr->enhancedIOD_valid)
+    {
+      svPolynomial.is_valid |= ULP_GNSS_SV_POLY_BIT_ENHANCED_IOD;
+      svPolynomial.enhancedIOD = gnss_sv_poly_ptr->enhancedIOD;
+    }
+
+    LocApiBase::reportSvPolynomial(svPolynomial);
+
+    LOC_LOGV("[SV_POLY_QMI] SV-Id:%d\n", svPolynomial.gnssSvId);
+  }
+  else
+  {
+     LOC_LOGV("[SV_POLY]  INVALID SV-Id:%d", svPolynomial.gnssSvId);
+  }
+} //reportSvPolynomial
+
+
+
+/* convert engine state report to loc eng format and send the converted
+   report to loc eng */
+void LocApiV02 :: reportEngineState (
+    const qmiLocEventEngineStateIndMsgT_v02 *engine_state_ptr)
+{
+
+  LOC_LOGV("%s:%d]: state = %d\n", __func__, __LINE__,
+                 engine_state_ptr->engineState);
+
+  struct MsgUpdateEngineState : public LocMsg {
+      LocApiV02* mpLocApiV02;
+      bool mEngineOn;
+      inline MsgUpdateEngineState(LocApiV02* pLocApiV02, bool engineOn) :
+                 LocMsg(), mpLocApiV02(pLocApiV02), mEngineOn(engineOn) {}
+      inline virtual void proc() const {
+          // If EngineOn is true and InSession is false and Engine is just turned off,
+          // then unregister the gps tracking specific event masks
+          if (mpLocApiV02->mEngineOn && !mpLocApiV02->mInSession && !mEngineOn) {
+              mpLocApiV02->registerEventMask(mpLocApiV02->mQmiMask);
+          }
+          mpLocApiV02->mEngineOn = mEngineOn;
+
+          if (mEngineOn) {
+              // if EngineOn and not InSession, then we have already stopped
+              // the fix, so do not send ENGINE_ON
+              if (mpLocApiV02->mInSession) {
+                  mpLocApiV02->reportStatus(GPS_STATUS_ENGINE_ON);
+                  mpLocApiV02->reportStatus(GPS_STATUS_SESSION_BEGIN);
+              }
+          } else {
+              mpLocApiV02->reportStatus(GPS_STATUS_SESSION_END);
+              mpLocApiV02->reportStatus(GPS_STATUS_ENGINE_OFF);
+          }
+      }
+  };
+
+  if (engine_state_ptr->engineState == eQMI_LOC_ENGINE_STATE_ON_V02)
+  {
+    sendMsg(new MsgUpdateEngineState(this, true));
+  }
+  else if (engine_state_ptr->engineState == eQMI_LOC_ENGINE_STATE_OFF_V02)
+  {
+    sendMsg(new MsgUpdateEngineState(this, false));
+  }
+  else
+  {
+    reportStatus(GPS_STATUS_NONE);
+  }
+
+}
+
+/* convert fix session state report to loc eng format and send the converted
+   report to loc eng */
+void LocApiV02 :: reportFixSessionState (
+    const qmiLocEventFixSessionStateIndMsgT_v02 *fix_session_state_ptr)
+{
+  GpsStatusValue status;
+  LOC_LOGD("%s:%d]: state = %d\n", __func__, __LINE__,
+                fix_session_state_ptr->sessionState);
+
+  status = GPS_STATUS_NONE;
+  if (fix_session_state_ptr->sessionState == eQMI_LOC_FIX_SESSION_STARTED_V02)
+  {
+    status = GPS_STATUS_SESSION_BEGIN;
+  }
+  else if (fix_session_state_ptr->sessionState
+           == eQMI_LOC_FIX_SESSION_FINISHED_V02)
+  {
+    status = GPS_STATUS_SESSION_END;
+  }
+  reportStatus(status);
+}
+
+/* convert NMEA report to loc eng format and send the converted
+   report to loc eng */
+void LocApiV02 :: reportNmea (
+  const qmiLocEventNmeaIndMsgT_v02 *nmea_report_ptr)
+{
+  LocApiBase::reportNmea(nmea_report_ptr->nmea,
+                         strlen(nmea_report_ptr->nmea));
+
+  LOC_LOGD("NMEA <%s", nmea_report_ptr->nmea);
+}
+
+/* convert and report an ATL request to loc engine */
+void LocApiV02 :: reportAtlRequest(
+  const qmiLocEventLocationServerConnectionReqIndMsgT_v02 * server_request_ptr)
+{
+  uint32_t connHandle = server_request_ptr->connHandle;
+  // service ATL open request; copy the WWAN type
+  if(server_request_ptr->requestType == eQMI_LOC_SERVER_REQUEST_OPEN_V02 )
+  {
+    AGpsType agpsType;
+    switch(server_request_ptr->wwanType)
+    {
+    case eQMI_LOC_WWAN_TYPE_INTERNET_V02:
+      agpsType = AGPS_TYPE_WWAN_ANY;
+      requestATL(connHandle, agpsType);
+      break;
+    case eQMI_LOC_WWAN_TYPE_AGNSS_V02:
+      agpsType = AGPS_TYPE_SUPL;
+      requestATL(connHandle, agpsType);
+      break;
+    case eQMI_LOC_WWAN_TYPE_AGNSS_EMERGENCY_V02:
+      requestSuplES(connHandle);
+      break;
+    default:
+      agpsType = AGPS_TYPE_WWAN_ANY;
+      requestATL(connHandle, agpsType);
+      break;
+    }
+  }
+  // service the ATL close request
+  else if (server_request_ptr->requestType == eQMI_LOC_SERVER_REQUEST_CLOSE_V02)
+  {
+    releaseATL(connHandle);
+  }
+}
+
+/* conver the NI report to loc eng format and send t loc engine */
+void LocApiV02 :: reportNiRequest(
+    const qmiLocEventNiNotifyVerifyReqIndMsgT_v02 *ni_req_ptr)
+{
+  GpsNiNotification notif;
+
+  /* initialize the notification*/
+  memset(notif.extras, 0, sizeof notif.extras);
+  memset(notif.text, 0, sizeof notif.text);
+  memset(notif.requestor_id, 0, sizeof notif.requestor_id);
+
+  /* NI timeout gets overwritten in LocApiEngAdapter,
+     initializing to 0 here */
+  notif.timeout     = 0;
+
+  notif.text_encoding = GPS_ENC_NONE ;
+
+  notif.requestor_id_encoding = GPS_ENC_UNKNOWN;
+
+  notif.notify_flags       = 0;
+
+  notif.default_response   = GPS_NI_RESPONSE_NORESP;
+
+  /*Handle Vx request */
+  if(ni_req_ptr->NiVxInd_valid == 1)
+  {
+     const qmiLocNiVxNotifyVerifyStructT_v02 *vx_req = &(ni_req_ptr->NiVxInd);
+
+     notif.ni_type     = GPS_NI_TYPE_VOICE;
+
+     // Requestor ID, the requestor id recieved is NULL terminated
+     hexcode(notif.requestor_id, sizeof notif.requestor_id,
+             (char *)vx_req->requestorId, vx_req->requestorId_len );
+  }
+
+  /* Handle UMTS CP request*/
+  else if(ni_req_ptr->NiUmtsCpInd_valid == 1)
+  {
+    const qmiLocNiUmtsCpNotifyVerifyStructT_v02 *umts_cp_req =
+       &ni_req_ptr->NiUmtsCpInd;
+
+    notif.ni_type     = GPS_NI_TYPE_UMTS_CTRL_PLANE;
+
+    /* notificationText should always be a NULL terminated string */
+    hexcode(notif.text, sizeof notif.text,
+            (char *)umts_cp_req->notificationText,
+            umts_cp_req->notificationText_len);
+
+    /* Store requestor ID */
+    hexcode(notif.requestor_id, sizeof(notif.requestor_id),
+            (char *)umts_cp_req->requestorId.codedString,
+            umts_cp_req->requestorId.codedString_len);
+
+   /* convert encodings */
+    notif.text_encoding = convertNiEncoding(umts_cp_req->dataCodingScheme);
+
+    notif.requestor_id_encoding =
+      convertNiEncoding(umts_cp_req->requestorId.dataCodingScheme);
+
+    /* LCS address (using extras field) */
+    if ( umts_cp_req->clientAddress_len != 0)
+    {
+      char lcs_addr[32]; // Decoded LCS address for UMTS CP NI
+
+      // Copy LCS Address into notif.extras in the format: Address = 012345
+      strlcat(notif.extras, LOC_NI_NOTIF_KEY_ADDRESS, sizeof (notif.extras));
+      strlcat(notif.extras, " = ", sizeof notif.extras);
+      int addr_len = 0;
+      const char *address_source = NULL;
+      address_source = (char *)umts_cp_req->clientAddress;
+      // client Address is always NULL terminated
+      addr_len = decodeAddress(lcs_addr, sizeof(lcs_addr), address_source,
+                               umts_cp_req->clientAddress_len);
+
+      // The address is ASCII string
+      if (addr_len)
+      {
+        strlcat(notif.extras, lcs_addr, sizeof notif.extras);
+      }
+    }
+
+  }
+  else if(ni_req_ptr->NiSuplInd_valid == 1)
+  {
+    const qmiLocNiSuplNotifyVerifyStructT_v02 *supl_req =
+      &ni_req_ptr->NiSuplInd;
+
+    notif.ni_type     = GPS_NI_TYPE_UMTS_SUPL;
+
+    // Client name
+    if (supl_req->valid_flags & QMI_LOC_SUPL_CLIENT_NAME_MASK_V02)
+    {
+      hexcode(notif.text, sizeof(notif.text),
+              (char *)supl_req->clientName.formattedString,
+              supl_req->clientName.formattedString_len);
+      LOC_LOGV("%s:%d]: SUPL NI: client_name: %s \n", __func__, __LINE__,
+          notif.text);
+    }
+    else
+    {
+      LOC_LOGV("%s:%d]: SUPL NI: client_name not present.",
+          __func__, __LINE__);
+    }
+
+    // Requestor ID
+    if (supl_req->valid_flags & QMI_LOC_SUPL_REQUESTOR_ID_MASK_V02)
+    {
+      hexcode(notif.requestor_id, sizeof notif.requestor_id,
+              (char*)supl_req->requestorId.formattedString,
+              supl_req->requestorId.formattedString_len );
+
+      LOC_LOGV("%s:%d]: SUPL NI: requestor_id: %s \n", __func__, __LINE__,
+          notif.requestor_id);
+    }
+    else
+    {
+      LOC_LOGV("%s:%d]: SUPL NI: requestor_id not present.",
+          __func__, __LINE__);
+    }
+
+    // Encoding type
+    if (supl_req->valid_flags & QMI_LOC_SUPL_DATA_CODING_SCHEME_MASK_V02)
+    {
+      notif.text_encoding = convertNiEncoding(supl_req->dataCodingScheme);
+
+      notif.requestor_id_encoding = convertNiEncoding(supl_req->dataCodingScheme);
+    }
+    else
+    {
+      notif.text_encoding = notif.requestor_id_encoding = GPS_ENC_UNKNOWN;
+    }
+
+    // ES SUPL
+    if(ni_req_ptr->suplEmergencyNotification_valid ==1)
+    {
+        const qmiLocEmergencyNotificationStructT_v02 *supl_emergency_request =
+        &ni_req_ptr->suplEmergencyNotification;
+
+        notif.ni_type = GPS_NI_TYPE_EMERGENCY_SUPL;
+    }
+
+  } //ni_req_ptr->NiSuplInd_valid == 1
+  else
+  {
+    LOC_LOGE("%s:%d]: unknown request event \n",__func__, __LINE__);
+    return;
+  }
+
+  // Set default_response & notify_flags
+  convertNiNotifyVerifyType(&notif, ni_req_ptr->notificationType);
+
+  qmiLocEventNiNotifyVerifyReqIndMsgT_v02 *ni_req_copy_ptr =
+    (qmiLocEventNiNotifyVerifyReqIndMsgT_v02 *)malloc(sizeof(*ni_req_copy_ptr));
+
+  if( NULL != ni_req_copy_ptr)
+  {
+    memcpy(ni_req_copy_ptr, ni_req_ptr, sizeof(*ni_req_copy_ptr));
+
+    requestNiNotify(notif, (const void*)ni_req_copy_ptr);
+  }
+  else
+  {
+    LOC_LOGE("%s:%d]: Error copying NI request\n", __func__, __LINE__);
+  }
+
+}
+
+/* If Confidence value is less than 68%, then scale the accuracy value to
+   68%.confidence.*/
+void LocApiV02 :: scaleAccuracyTo68PercentConfidence(
+                                                const uint8_t confidenceValue,
+                                                GpsLocation &gpsLocation)
+{
+  if (confidenceValue < 68)
+  {
+    // get scaling value based on 2D% confidence scaling table
+    for (uint8_t iter = 0; iter < CONF_SCALER_ARRAY_MAX; iter++)
+    {
+      if (confidenceValue <= confScalers[iter].confidence)
+      {
+        LOC_LOGD("Scaler value:%f",confScalers[iter].scaler_to_68);
+        gpsLocation.accuracy *= confScalers[iter].scaler_to_68;
+        break;
+      }
+    }
+  }
+}
+
+/* Report the Xtra Server Url from the modem to HAL*/
+void LocApiV02 :: reportXtraServerUrl(
+                const qmiLocEventInjectPredictedOrbitsReqIndMsgT_v02*
+                server_request_ptr)
+{
+
+  if (server_request_ptr->serverList.serverList_len == 1)
+  {
+    reportXtraServer(server_request_ptr->serverList.serverList[0].serverUrl,
+                     "",
+                     "",
+                     QMI_LOC_MAX_SERVER_ADDR_LENGTH_V02);
+  }
+  else if (server_request_ptr->serverList.serverList_len == 2)
+  {
+    reportXtraServer(server_request_ptr->serverList.serverList[0].serverUrl,
+                     server_request_ptr->serverList.serverList[1].serverUrl,
+                     "",
+                     QMI_LOC_MAX_SERVER_ADDR_LENGTH_V02);
+  }
+  else
+  {
+    reportXtraServer(server_request_ptr->serverList.serverList[0].serverUrl,
+                     server_request_ptr->serverList.serverList[1].serverUrl,
+                     server_request_ptr->serverList.serverList[2].serverUrl,
+                     QMI_LOC_MAX_SERVER_ADDR_LENGTH_V02);
+  }
+
+}
+
+/* convert Ni Encoding type from QMI_LOC to loc eng format */
+GpsNiEncodingType LocApiV02 ::convertNiEncoding(
+  qmiLocNiDataCodingSchemeEnumT_v02 loc_encoding)
+{
+   GpsNiEncodingType enc = GPS_ENC_UNKNOWN;
+
+   switch (loc_encoding)
+   {
+     case eQMI_LOC_NI_SUPL_UTF8_V02:
+       enc = GPS_ENC_SUPL_UTF8;
+       break;
+     case eQMI_LOC_NI_SUPL_UCS2_V02:
+       enc = GPS_ENC_SUPL_UCS2;
+       break;
+     case eQMI_LOC_NI_SUPL_GSM_DEFAULT_V02:
+       enc = GPS_ENC_SUPL_GSM_DEFAULT;
+       break;
+     case eQMI_LOC_NI_SS_LANGUAGE_UNSPEC_V02:
+       enc = GPS_ENC_SUPL_GSM_DEFAULT; // SS_LANGUAGE_UNSPEC = GSM
+       break;
+     default:
+       break;
+   }
+
+   return enc;
+}
+
+/*convert NI notify verify type from QMI LOC to loc eng format*/
+bool LocApiV02 :: convertNiNotifyVerifyType (
+  GpsNiNotification *notif,
+  qmiLocNiNotifyVerifyEnumT_v02 notif_priv)
+{
+  switch (notif_priv)
+   {
+   case eQMI_LOC_NI_USER_NO_NOTIFY_NO_VERIFY_V02:
+      notif->notify_flags = 0;
+      break;
+
+   case eQMI_LOC_NI_USER_NOTIFY_ONLY_V02:
+      notif->notify_flags = GPS_NI_NEED_NOTIFY;
+      break;
+
+   case eQMI_LOC_NI_USER_NOTIFY_VERIFY_ALLOW_NO_RESP_V02:
+      notif->notify_flags = GPS_NI_NEED_NOTIFY | GPS_NI_NEED_VERIFY;
+      notif->default_response = GPS_NI_RESPONSE_ACCEPT;
+      break;
+
+   case eQMI_LOC_NI_USER_NOTIFY_VERIFY_NOT_ALLOW_NO_RESP_V02:
+      notif->notify_flags = GPS_NI_NEED_NOTIFY | GPS_NI_NEED_VERIFY;
+      notif->default_response = GPS_NI_RESPONSE_DENY;
+      break;
+
+   case eQMI_LOC_NI_USER_NOTIFY_VERIFY_PRIVACY_OVERRIDE_V02:
+      notif->notify_flags = GPS_NI_PRIVACY_OVERRIDE;
+      break;
+
+   default:
+      return false;
+   }
+
+   return true;
+}
+
+/* convert and report GNSS measurement data to loc eng */
+void LocApiV02 :: reportGnssMeasurementData(
+  const qmiLocEventGnssSvMeasInfoIndMsgT_v02& gnss_measurement_report_ptr)
+{
+    LOC_LOGV ("%s:%d]: entering\n", __func__, __LINE__);
+
+    GnssData gnssMeasurementData;
+    memset (&gnssMeasurementData, 0, sizeof(GnssData));
+
+    int svMeasurment_len = 0;
+
+    // size
+    gnssMeasurementData.size = sizeof(GnssData);
+
+    // number of measurements
+    if (gnss_measurement_report_ptr.svMeasurement_valid) {
+        svMeasurment_len =
+            gnss_measurement_report_ptr.svMeasurement_len;
+        gnssMeasurementData.measurement_count = svMeasurment_len;
+        LOC_LOGV ("%s:%d]: there are %d SV measurements\n",
+                  __func__, __LINE__, svMeasurment_len);
+    } else {
+        LOC_LOGV ("%s:%d]: there is no valid SV measurements\n",
+                  __func__, __LINE__);
+    }
+
+    if (svMeasurment_len != 0 &&
+        gnss_measurement_report_ptr.system == eQMI_LOC_SV_SYSTEM_GPS_V02) {
+
+        // the array of measurements
+        int index = 0;
+        while(svMeasurment_len > 0) {
+            convertGnssMeasurements(gnssMeasurementData.measurements[index],
+                                   gnss_measurement_report_ptr.svMeasurement[index]);
+            index++;
+            svMeasurment_len--;
+        }
+
+        // the GPS clock time reading
+        convertGnssClock(gnssMeasurementData.clock,
+                        gnss_measurement_report_ptr);
+
+        // calling the base
+        LOC_LOGV ("%s:%d]: calling LocApiBase::reportGnssMeasurementData.\n",
+                  __func__, __LINE__);
+        LocApiBase::reportGnssMeasurementData(gnssMeasurementData);
+    } else {
+        LOC_LOGV ("%s:%d]: There is no GNSS measurement.\n",
+                  __func__, __LINE__);
+    }
+}
+
+/*convert GnssMeasurement type from QMI LOC to loc eng format*/
+void LocApiV02 :: convertGnssMeasurements (GnssMeasurement& gnssMeasurement,
+    const qmiLocSVMeasurementStructT_v02& gnss_measurement_info)
+{
+    LOC_LOGV ("%s:%d]: entering\n", __func__, __LINE__);
+
+    // size
+    gnssMeasurement.size = sizeof(GnssMeasurement);
+
+    // flag initiation
+    GnssMeasurementFlags flags = 0;
+
+    // svid
+    gnssMeasurement.svid = gnss_measurement_info.gnssSvId;
+
+    // constellation
+    gnssMeasurement.constellation = GNSS_CONSTELLATION_GPS;
+
+    // time_offset_ns
+    if (0 != gnss_measurement_info.measLatency)
+    {
+        LOC_LOGV("%s:%d]: measLatency is not 0\n", __func__, __LINE__);
+    }
+    gnssMeasurement.time_offset_ns = 0.0;
+
+    // state & received_sv_time_in_ns & received_gps_tow_uncertainty_ns
+    uint64_t validMask = gnss_measurement_info.measurementStatus &
+                         gnss_measurement_info.validMeasStatusMask;
+    uint64_t bitSynMask = QMI_LOC_MASK_MEAS_STATUS_BE_CONFIRM_V02 |
+                          QMI_LOC_MASK_MEAS_STATUS_SB_VALID_V02;
+    double gpsTowUncNs = (double)gnss_measurement_info.svTimeSpeed.svTimeUncMs * 1e6;
+
+    if (validMask & QMI_LOC_MASK_MEAS_STATUS_MS_VALID_V02) {
+        /* sub-frame decode & TOW decode */
+        gnssMeasurement.state = GNSS_MEASUREMENT_STATE_SUBFRAME_SYNC |
+                                GNSS_MEASUREMENT_STATE_TOW_DECODED |
+                                GNSS_MEASUREMENT_STATE_BIT_SYNC |
+                                GNSS_MEASUREMENT_STATE_CODE_LOCK;
+        gnssMeasurement.received_sv_time_in_ns =
+            (int64_t)(((double)gnss_measurement_info.svTimeSpeed.svTimeMs +
+             (double)gnss_measurement_info.svTimeSpeed.svTimeSubMs) * 1e6);
+
+        gnssMeasurement.received_sv_time_uncertainty_in_ns = (int64_t)gpsTowUncNs;
+
+    } else if ((validMask & bitSynMask) == bitSynMask) {
+        /* bit sync */
+        gnssMeasurement.state = GNSS_MEASUREMENT_STATE_BIT_SYNC |
+                                GNSS_MEASUREMENT_STATE_CODE_LOCK;
+        gnssMeasurement.received_sv_time_in_ns =
+            (int64_t)(fmod(((double)gnss_measurement_info.svTimeSpeed.svTimeMs +
+                  (double)gnss_measurement_info.svTimeSpeed.svTimeSubMs), 20) * 1e6);
+        gnssMeasurement.received_sv_time_uncertainty_in_ns = (int64_t)gpsTowUncNs;
+
+    } else if (validMask & QMI_LOC_MASK_MEAS_STATUS_SM_VALID_V02) {
+        /* code lock */
+        gnssMeasurement.state = GNSS_MEASUREMENT_STATE_CODE_LOCK;
+        gnssMeasurement.received_sv_time_in_ns =
+             (int64_t)((double)gnss_measurement_info.svTimeSpeed.svTimeSubMs * 1e6);
+        gnssMeasurement.received_sv_time_uncertainty_in_ns = (int64_t)gpsTowUncNs;
+
+    } else {
+        /* by default */
+        gnssMeasurement.state = GNSS_MEASUREMENT_STATE_UNKNOWN;
+        gnssMeasurement.received_sv_time_in_ns = 0;
+        gnssMeasurement.received_sv_time_uncertainty_in_ns = 0;
+    }
+
+    // c_n0_dbhz
+    gnssMeasurement.c_n0_dbhz = gnss_measurement_info.CNo/10.0;
+
+    if (QMI_LOC_MASK_MEAS_STATUS_VELOCITY_FINE_V02 == (gnss_measurement_info.measurementStatus & QMI_LOC_MASK_MEAS_STATUS_VELOCITY_FINE_V02))
+    {
+        LOC_LOGV ("%s:%d]: FINE mS=0x%4X fS=%f fSU=%f dS=%f dSU=%f\n", __func__, __LINE__, gnss_measurement_info.measurementStatus,
+        gnss_measurement_info.fineSpeed, gnss_measurement_info.fineSpeedUnc,
+        gnss_measurement_info.svTimeSpeed.dopplerShift, gnss_measurement_info.svTimeSpeed.dopplerShiftUnc);
+        // pseudorange_rate_mps
+        gnssMeasurement.pseudorange_rate_mps = gnss_measurement_info.fineSpeed;
+
+        // pseudorange_rate_uncertainty_mps
+        gnssMeasurement.pseudorange_rate_uncertainty_mps = gnss_measurement_info.fineSpeedUnc;
+    }
+    else
+    {
+        LOC_LOGV ("%s:%d]: COARSE mS=0x%4X fS=%f fSU=%f dS=%f dSU=%f\n", __func__, __LINE__, gnss_measurement_info.measurementStatus,
+        gnss_measurement_info.fineSpeed, gnss_measurement_info.fineSpeedUnc,
+        gnss_measurement_info.svTimeSpeed.dopplerShift, gnss_measurement_info.svTimeSpeed.dopplerShiftUnc);
+        // pseudorange_rate_mps
+        gnssMeasurement.pseudorange_rate_mps = gnss_measurement_info.svTimeSpeed.dopplerShift;
+
+        // pseudorange_rate_uncertainty_mps
+        gnssMeasurement.pseudorange_rate_uncertainty_mps = gnss_measurement_info.svTimeSpeed.dopplerShiftUnc;
+    }
+
+    // accumulated_delta_range_state
+    gnssMeasurement.accumulated_delta_range_state = GNSS_ADR_STATE_UNKNOWN;
+
+    // multipath_indicator
+    gnssMeasurement.multipath_indicator = GNSS_MULTIPATH_INDICATOR_UNKNOWN;
+
+    gnssMeasurement.flags = flags;
+
+    LOC_LOGV(" %s:%d]: GNSS measurement raw data received form modem: \n", __func__, __LINE__);
+    LOC_LOGV(" Input => gnssSvId=%d CNo=%d measurementStatus=0x%04x%04x\n",
+             gnss_measurement_info.gnssSvId,                                    // %d
+             gnss_measurement_info.CNo,                                         // %d
+             (uint32_t)(gnss_measurement_info.measurementStatus >> 32),         // %04x Upper 32
+             (uint32_t)(gnss_measurement_info.measurementStatus & 0xFFFFFFFF)); // %04x Lower 32
+
+    LOC_LOGV("  dopplerShift=%f dopplerShiftUnc=%f fineSpeed=%f fineSpeedUnc=%f\n",
+             gnss_measurement_info.svTimeSpeed.dopplerShift,                    // %f
+             gnss_measurement_info.svTimeSpeed.dopplerShiftUnc,                 // %f
+             gnss_measurement_info.fineSpeed,                                   // %f
+             gnss_measurement_info.fineSpeedUnc);                               // %f
+
+    LOC_LOGV("  svTimeMs=%u svTimeSubMs=%f svTimeUncMs=%f\n",
+             gnss_measurement_info.svTimeSpeed.svTimeMs,                        // %u
+             gnss_measurement_info.svTimeSpeed.svTimeSubMs,                     // %f
+             gnss_measurement_info.svTimeSpeed.svTimeUncMs);                    // %f
+
+    LOC_LOGV("  svStatus=0x%02x validMeasStatusMask=0x%04x%04x\n",
+             (uint32_t)(gnss_measurement_info.svStatus),                        // %02x
+             (uint32_t)(gnss_measurement_info.validMeasStatusMask >> 32),       // %04x Upper 32
+             (uint32_t)(gnss_measurement_info.validMeasStatusMask & 0xFFFFFFFF));   // %04x Lower 32
+
+    LOC_LOGV(" %s:%d]: GNSS measurement data after conversion:\n", __func__, __LINE__);
+    LOC_LOGV(" Output => size=%d svid=%d time_offset_ns=%f state=%d\n",
+             gnssMeasurement.size,                              // %d
+             gnssMeasurement.svid,                               // %d
+             gnssMeasurement.time_offset_ns,                    // %f
+             gnssMeasurement.state);                            // %d
+
+    LOC_LOGV("  received_sv_time_in_ns=%lld received_sv_time_uncertainty_in_ns=%lld c_n0_dbhz=%g\n",
+             gnssMeasurement.received_sv_time_in_ns,            // %lld
+             gnssMeasurement.received_sv_time_uncertainty_in_ns,// %lld
+             gnssMeasurement.c_n0_dbhz);                        // %g
+
+    LOC_LOGV("  pseudorange_rate_mps=%g pseudorange_rate_uncertainty_mps=%g\n",
+             gnssMeasurement.pseudorange_rate_mps,              // %g
+             gnssMeasurement.pseudorange_rate_uncertainty_mps); // %g
+}
+
+/*convert GnssClock type from QMI LOC to loc eng format*/
+void LocApiV02 :: convertGnssClock (GnssClock& gnssClock,
+    const qmiLocEventGnssSvMeasInfoIndMsgT_v02& gnss_measurement_info)
+{
+    static uint32_t oldRefFCount = 0;
+    static uint32_t newRefFCount = 0;
+    static uint32_t oldDiscCount = 0;
+    static uint32_t newDiscCount = 0;
+    static uint32_t localDiscCount = 0;
+
+    LOC_LOGV ("%s:%d]: entering\n", __func__, __LINE__);
+
+    // size
+    gnssClock.size = sizeof(GnssClock);
+
+    // flag initiation
+    GnssClockFlags flags = 0;
+
+    if (gnss_measurement_info.systemTimeExt_valid &&
+        gnss_measurement_info.numClockResets_valid) {
+        newRefFCount = gnss_measurement_info.systemTimeExt.refFCount;
+        newDiscCount = gnss_measurement_info.numClockResets;
+        if ((true == mMeasurementsStarted) ||
+            (oldDiscCount != newDiscCount) ||
+            (newRefFCount <= oldRefFCount))
+        {
+            if (true == mMeasurementsStarted)
+            {
+                mMeasurementsStarted = false;
+            }
+            localDiscCount++;
+        }
+        oldDiscCount = newDiscCount;
+        oldRefFCount = newRefFCount;
+
+        // time_ns & time_uncertainty_ns
+        gnssClock.time_ns = (int64_t)gnss_measurement_info.systemTimeExt.refFCount * 1e6;
+        gnssClock.hw_clock_discontinuity_count = localDiscCount;
+        gnssClock.time_uncertainty_ns = 0.0;
+
+        if (gnss_measurement_info.systemTime_valid) {
+            uint16_t systemWeek = gnss_measurement_info.systemTime.systemWeek;
+            uint32_t systemMsec = gnss_measurement_info.systemTime.systemMsec;
+            float sysClkBias = gnss_measurement_info.systemTime.systemClkTimeBias;
+            float sysClkUncMs = gnss_measurement_info.systemTime.systemClkTimeUncMs;
+            bool isTimeValid = (sysClkUncMs <= 16.0f); // 16ms
+            double gps_time_ns;
+
+            if (systemWeek != C_GPS_WEEK_UNKNOWN && isTimeValid) {
+                // full_bias_ns, bias_ns & bias_uncertainty_ns
+                double temp = (double)(systemWeek)* (double)WEEK_MSECS + (double)systemMsec;
+                gps_time_ns = (double)temp*1e6 - (double)((int)(sysClkBias*1e6));
+                gnssClock.full_bias_ns = (int64_t)(gnssClock.time_ns - gps_time_ns);
+                gnssClock.bias_ns = (double)(gnssClock.time_ns - gps_time_ns) - gnssClock.full_bias_ns;
+                gnssClock.bias_uncertainty_ns = (double)sysClkUncMs * 1e6;
+                flags |= (GNSS_CLOCK_HAS_FULL_BIAS | GNSS_CLOCK_HAS_BIAS | GNSS_CLOCK_HAS_BIAS_UNCERTAINTY);
+            }
+        }
+    }
+
+    // drift_nsps & drift_uncertainty_nsps
+    if (gnss_measurement_info.rcvrClockFrequencyInfo_valid)
+    {
+        double driftMPS = gnss_measurement_info.rcvrClockFrequencyInfo.clockDrift;
+        double driftUncMPS = gnss_measurement_info.rcvrClockFrequencyInfo.clockDriftUnc;
+
+        gnssClock.drift_nsps = driftMPS * MPS_TO_NSPS;
+        gnssClock.drift_uncertainty_nsps = driftUncMPS * MPS_TO_NSPS;
+
+        flags |= (GNSS_CLOCK_HAS_DRIFT | GNSS_CLOCK_HAS_DRIFT_UNCERTAINTY);
+    }
+
+    gnssClock.flags = flags;
+
+    LOC_LOGV(" %s:%d]: GNSS measurement clock data received from modem: \n", __func__, __LINE__);
+    LOC_LOGV(" Input => systemTime_valid=%d systemTimeExt_valid=%d numClockResets_valid=%d\n",
+             gnss_measurement_info.systemTime_valid,                      // %d
+             gnss_measurement_info.systemTimeExt_valid,                   // %d
+        gnss_measurement_info.numClockResets_valid);                 // %d
+
+    LOC_LOGV("  systemWeek=%d systemMsec=%d systemClkTimeBias=%f\n",
+             gnss_measurement_info.systemTime.systemWeek,                 // %d
+             gnss_measurement_info.systemTime.systemMsec,                 // %d
+        gnss_measurement_info.systemTime.systemClkTimeBias);         // %f
+
+    LOC_LOGV("  systemClkTimeUncMs=%f refFCount=%d numClockResets=%d\n",
+             gnss_measurement_info.systemTime.systemClkTimeUncMs,         // %f
+        gnss_measurement_info.systemTimeExt.refFCount,               // %d
+        gnss_measurement_info.numClockResets);                       // %d
+
+    LOC_LOGV("  clockDrift=%f clockDriftUnc=%f\n",
+        gnss_measurement_info.rcvrClockFrequencyInfo.clockDrift,     // %f
+        gnss_measurement_info.rcvrClockFrequencyInfo.clockDriftUnc); // %f
+
+
+    LOC_LOGV(" %s:%d]: GNSS measurement clock after conversion: \n", __func__, __LINE__);
+    LOC_LOGV(" Output => time_ns=%lld\n",
+        gnssClock.time_ns);                          // %lld
+
+    LOC_LOGV("  full_bias_ns=%lld bias_ns=%g bias_uncertainty_ns=%g\n",
+        gnssClock.full_bias_ns,                      // %lld
+        gnssClock.bias_ns,                           // %g
+        gnssClock.bias_uncertainty_ns);              // %g
+
+    LOC_LOGV("  drift_nsps=%g drift_uncertainty_nsps=%g\n",
+        gnssClock.drift_nsps,                        // %g
+        gnssClock.drift_uncertainty_nsps);           // %g
+
+    LOC_LOGV("  hw_clock_discontinuity_count=%d flags=0x%04x\n",
+        gnssClock.hw_clock_discontinuity_count,     // %lld
+        gnssClock.flags);                           // %04x
+}
+
+/* event callback registered with the loc_api v02 interface */
+void LocApiV02 :: eventCb(locClientHandleType clientHandle,
+  uint32_t eventId, locClientEventIndUnionType eventPayload)
+{
+  LOC_LOGD("%s:%d]: event id = %d\n", __func__, __LINE__,
+                eventId);
+
+  switch(eventId)
+  {
+    //Position Report
+    case QMI_LOC_EVENT_POSITION_REPORT_IND_V02:
+      reportPosition(eventPayload.pPositionReportEvent);
+      break;
+
+    // Satellite report
+    case QMI_LOC_EVENT_GNSS_SV_INFO_IND_V02:
+      reportSv(eventPayload.pGnssSvInfoReportEvent);
+      break;
+
+    // Status report
+    case QMI_LOC_EVENT_ENGINE_STATE_IND_V02:
+      reportEngineState(eventPayload.pEngineState);
+      break;
+
+    case QMI_LOC_EVENT_FIX_SESSION_STATE_IND_V02:
+      reportFixSessionState(eventPayload.pFixSessionState);
+      break;
+
+    // NMEA
+    case QMI_LOC_EVENT_NMEA_IND_V02:
+      reportNmea(eventPayload.pNmeaReportEvent);
+      break;
+
+    // XTRA request
+    case QMI_LOC_EVENT_INJECT_PREDICTED_ORBITS_REQ_IND_V02:
+      LOC_LOGD("%s:%d]: XTRA download request\n", __func__,
+                    __LINE__);
+      reportXtraServerUrl(eventPayload.pInjectPredictedOrbitsReqEvent);
+      requestXtraData();
+      break;
+
+    // time request
+    case QMI_LOC_EVENT_INJECT_TIME_REQ_IND_V02:
+      LOC_LOGD("%s:%d]: Time request\n", __func__,
+                    __LINE__);
+      requestTime();
+      break;
+
+    //position request
+    case QMI_LOC_EVENT_INJECT_POSITION_REQ_IND_V02:
+      LOC_LOGD("%s:%d]: Position request\n", __func__,
+                    __LINE__);
+      requestLocation();
+      break;
+
+    // NI request
+    case QMI_LOC_EVENT_NI_NOTIFY_VERIFY_REQ_IND_V02:
+      reportNiRequest(eventPayload.pNiNotifyVerifyReqEvent);
+      break;
+
+    // AGPS connection request
+    case QMI_LOC_EVENT_LOCATION_SERVER_CONNECTION_REQ_IND_V02:
+      reportAtlRequest(eventPayload.pLocationServerConnReqEvent);
+      break;
+
+    case QMI_LOC_EVENT_GNSS_MEASUREMENT_REPORT_IND_V02:
+      LOC_LOGD("%s:%d]: GNSS Measurement Report\n", __func__,
+               __LINE__);
+      reportSvMeasurement(eventPayload.pGnssSvRawInfoEvent);
+      reportGnssMeasurementData(*eventPayload.pGnssSvRawInfoEvent); /*TBD merge into one function*/
+      break;
+
+    case QMI_LOC_EVENT_SV_POLYNOMIAL_REPORT_IND_V02:
+      LOC_LOGD("%s:%d]: GNSS SV Polynomial Ind\n", __func__,
+               __LINE__);
+      reportSvPolynomial(eventPayload.pGnssSvPolyInfoEvent);
+      break;
+  }
+}
+
+/* Call the service LocAdapterBase down event*/
+void LocApiV02 :: errorCb(locClientHandleType handle,
+                             locClientErrorEnumType errorId)
+{
+  if(errorId == eLOC_CLIENT_ERROR_SERVICE_UNAVAILABLE)
+  {
+    LOC_LOGE("%s:%d]: Service unavailable error\n",
+                  __func__, __LINE__);
+
+    handleEngineDownEvent();
+
+    /* immediately send the engine up event so that
+    the loc engine re-initializes the adapter and the
+    loc-api_v02 interface */
+
+    mGnssMeasurementSupported = sup_unknown;
+
+    handleEngineUpEvent();
+  }
+}
+
+static void ds_client_global_event_cb(ds_client_status_enum_type result,
+                                       void *loc_adapter_cookie)
+{
+    LocApiV02 *locApiV02Instance = (LocApiV02 *)loc_adapter_cookie;
+
+    locApiV02Instance->ds_client_event_cb(result);
+    return;
+}
+
+void LocApiV02::ds_client_event_cb(ds_client_status_enum_type result)
+{
+    if(result == E_DS_CLIENT_DATA_CALL_CONNECTED) {
+        LOC_LOGD("%s:%d]: Emergency call is up", __func__, __LINE__);
+        reportDataCallOpened();
+    }
+    else if(result == E_DS_CLIENT_DATA_CALL_DISCONNECTED) {
+        LOC_LOGE("%s:%d]: Emergency call is stopped", __func__, __LINE__);
+        reportDataCallClosed();
+    }
+    return;
+}
+
+static const ds_client_cb_data ds_client_cb = {
+    ds_client_global_event_cb
+};
+
+int LocApiV02 :: initDataServiceClient()
+{
+    int ret=0;
+    if (NULL == dsLibraryHandle)
+    {
+      dsLibraryHandle = dlopen(DS_CLIENT_LIB_NAME, RTLD_NOW);
+      if (NULL == dsLibraryHandle)
+      {
+        const char * err = dlerror();
+        if (NULL == err)
+        {
+          err = "Unknown";
+        }
+        LOC_LOGE("%s:%d]: failed to load library %s; error=%s",
+                 __func__, __LINE__,
+                 DS_CLIENT_LIB_NAME,
+                 err);
+        ret = 1;
+      }
+      if (NULL != dsLibraryHandle)
+      {
+        ds_client_get_iface_fn *getIface = NULL;
+
+        getIface = (ds_client_get_iface_fn*)dlsym(dsLibraryHandle,
+                                                  DS_CLIENT_GET_INTERFACE_FN);
+        if (NULL != getIface)
+        {
+          dsClientIface = getIface();
+        }
+        else
+        {
+          const char * err = dlerror();
+          if (NULL == err)
+          {
+            err = "Unknown";
+          }
+          LOC_LOGE("%s:%d]: failed to find symbol %s; error=%s",
+                   __func__, __LINE__,
+                   DS_CLIENT_GET_INTERFACE_FN,
+                   err);
+        }
+      }
+    }
+    if (NULL != dsClientIface && NULL != dsClientIface->pfn_init)
+    {
+      ds_client_status_enum_type dsret = dsClientIface->pfn_init();
+      if (dsret != E_DS_CLIENT_SUCCESS)
+      {
+        LOC_LOGE("%s:%d]: Error during client initialization %d",
+                 __func__, __LINE__,
+                 (int)dsret);
+
+        ret = 3;
+      }
+    }
+    else
+    {
+      if (NULL == dsClientIface)
+      {
+          LOC_LOGE("%s:%d]: dsClientIface == NULL",
+                   __func__, __LINE__);
+      }
+      else
+      {
+          LOC_LOGE("%s:%d]: dsClientIface->pfn_init == NULL",
+                   __func__, __LINE__);
+      }
+      ret = 2;
+    }
+    LOC_LOGD("%s:%d]: ret = %d\n", __func__, __LINE__,ret);
+    return ret;
+}
+
+int LocApiV02 :: openAndStartDataCall()
+{
+    loc_api_adapter_err ret = LOC_API_ADAPTER_ERR_GENERAL_FAILURE;
+    int profile_index = -1;
+    int pdp_type = -1;
+    ds_client_status_enum_type result = E_DS_CLIENT_FAILURE_NOT_INITIALIZED;
+
+    if (NULL != dsClientIface &&
+        NULL != dsClientIface->pfn_open_call &&
+        NULL != dsClientIface->pfn_start_call)
+    {
+      result = dsClientIface->pfn_open_call(&dsClientHandle,
+                                            &ds_client_cb,
+                                            (void *)this,
+                                            &profile_index,
+                                            &pdp_type);
+    }
+    if (E_DS_CLIENT_SUCCESS == result)
+    {
+        result = dsClientIface->pfn_start_call(dsClientHandle,
+                                               profile_index,
+                                               pdp_type);
+
+        if(result == E_DS_CLIENT_SUCCESS) {
+            LOC_LOGD("%s:%d]: Request to start Emergency call sent\n",
+                 __func__, __LINE__);
+        ret = LOC_API_ADAPTER_ERR_SUCCESS;
+        }
+        else {
+            LOC_LOGE("%s:%d]: Unable to bring up emergency call using DS. result = %d",
+                 __func__, __LINE__, (int)result);
+            ret = LOC_API_ADAPTER_ERR_UNSUPPORTED;
+        }
+    }
+    else if(result == E_DS_CLIENT_RETRY_LATER) {
+        LOC_LOGE("%s:%d]: Could not start emergency call. Retry after delay\n",
+                 __func__, __LINE__);
+        ret = LOC_API_ADAPTER_ERR_ENGINE_BUSY;
+    }
+    else {
+        LOC_LOGE("%s:%d]: Unable to bring up emergency call using DS. ret = %d",
+                 __func__, __LINE__, (int)ret);
+        ret = LOC_API_ADAPTER_ERR_UNSUPPORTED;
+    }
+
+    return (int)ret;
+}
+
+void LocApiV02 :: stopDataCall()
+{
+    ds_client_status_enum_type ret = E_DS_CLIENT_FAILURE_NOT_INITIALIZED;
+
+    if (NULL != dsClientIface &&
+        NULL != dsClientIface->pfn_stop_call)
+    {
+      ret = dsClientIface->pfn_stop_call(dsClientHandle);
+    }
+
+    if (ret == E_DS_CLIENT_SUCCESS) {
+        LOC_LOGD("%s:%d]: Request to Close SUPL ES call sent",
+                 __func__, __LINE__);
+    }
+    else {
+        if (ret == E_DS_CLIENT_FAILURE_INVALID_HANDLE) {
+            LOC_LOGE("%s:%d]: Conn handle not found for SUPL ES",
+                     __func__, __LINE__);
+        }
+        LOC_LOGE("%s:%d]: Could not close SUPL ES call. Ret: %d",
+                 __func__, __LINE__, ret);
+    }
+    return;
+}
+
+void LocApiV02 :: closeDataCall()
+{
+  int ret = 1;
+
+  if (NULL != dsClientIface &&
+      NULL != dsClientIface->pfn_close_call)
+  {
+    dsClientIface->pfn_close_call(&dsClientHandle);
+    ret = 0;
+  }
+
+  LOC_LOGD("%s:%d]: Release data client handle; ret=%d",
+           __func__, __LINE__, ret);
+}
+
+enum loc_api_adapter_err LocApiV02 ::
+getWwanZppFix(GpsLocation &zppLoc)
+{
+    locClientReqUnionType req_union;
+    qmiLocGetAvailWwanPositionReqMsgT_v02 zpp_req;
+    qmiLocGetAvailWwanPositionIndMsgT_v02 zpp_ind;
+    memset(&zpp_ind, 0, sizeof(zpp_ind));
+    memset(&zpp_req, 0, sizeof(zpp_req));
+    memset(&zppLoc, 0, sizeof(zppLoc));
+
+    req_union.pGetAvailWwanPositionReq = &zpp_req;
+
+    LOC_LOGD("%s:%d]: Get ZPP Fix from available wwan position\n", __func__, __LINE__);
+
+    locClientStatusEnumType status =
+        loc_sync_send_req(clientHandle,
+                          QMI_LOC_GET_AVAILABLE_WWAN_POSITION_REQ_V02,
+                          req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT,
+                          QMI_LOC_GET_AVAILABLE_WWAN_POSITION_IND_V02,
+                          &zpp_ind);
+
+    if (status != eLOC_CLIENT_SUCCESS ||
+        eQMI_LOC_SUCCESS_V02 != zpp_ind.status) {
+        LOC_LOGD ("%s:%d]: getWwanZppFix may not be supported by modem"
+                  " so will fallback to getBestAvailableZppFix"
+                  " status = %s, zpp_ind.status = %s ",
+                  __func__, __LINE__,
+                  loc_get_v02_client_status_name(status),
+                  loc_get_v02_qmi_status_name(zpp_ind.status));
+
+        LocPosTechMask tech_mask;
+        loc_api_adapter_err ret;
+        ret = getBestAvailableZppFix(zppLoc, tech_mask);
+        if (ret == LOC_API_ADAPTER_ERR_SUCCESS &&
+            tech_mask != LOC_POS_TECH_MASK_DEFAULT &&
+            tech_mask & LOC_POS_TECH_MASK_CELLID) {
+            return LOC_API_ADAPTER_ERR_SUCCESS;
+        } else {
+            LOC_LOGD ("%s:%d]: getBestAvailableZppFix failed or"
+                  " technoloy source includes GNSS that is not allowed"
+                  " ret = %u, tech_mask = 0x%X ",
+                  __func__, __LINE__, ret, tech_mask);
+            return LOC_API_ADAPTER_ERR_GENERAL_FAILURE;
+        }
+    }
+
+    LOC_LOGD("Got Zpp fix location validity (lat:%d, lon:%d, timestamp:%d accuracy:%d)",
+             zpp_ind.latitude_valid,
+             zpp_ind.longitude_valid,
+             zpp_ind.timestampUtc_valid,
+             zpp_ind.horUncCircular_valid);
+
+    LOC_LOGD("(%.7f, %.7f), timestamp %llu, accuracy %f",
+             zpp_ind.latitude,
+             zpp_ind.longitude,
+             zpp_ind.timestampUtc,
+             zpp_ind.horUncCircular);
+
+    zppLoc.size = sizeof(GpsLocation);
+    if (zpp_ind.timestampUtc_valid) {
+        zppLoc.timestamp = zpp_ind.timestampUtc;
+    }
+    else {
+        /* The UTC time from modem is not valid.
+        In this case, we use current system time instead.*/
+
+        struct timespec time_info_current;
+        clock_gettime(CLOCK_REALTIME,&time_info_current);
+        zppLoc.timestamp = (time_info_current.tv_sec)*1e3 +
+                           (time_info_current.tv_nsec)/1e6;
+        LOC_LOGD("zpp timestamp got from system: %llu", zppLoc.timestamp);
+    }
+
+    if ((zpp_ind.latitude_valid == false) ||
+        (zpp_ind.longitude_valid == false) ||
+        (zpp_ind.horUncCircular_valid == false)) {
+        return LOC_API_ADAPTER_ERR_GENERAL_FAILURE;
+    }
+
+    zppLoc.flags = GPS_LOCATION_HAS_LAT_LONG | GPS_LOCATION_HAS_ACCURACY;
+    zppLoc.latitude = zpp_ind.latitude;
+    zppLoc.longitude = zpp_ind.longitude;
+    zppLoc.accuracy = zpp_ind.horUncCircular;
+
+    // If horCircularConfidence_valid is true, and horCircularConfidence value
+    // is less than 68%, then scale the accuracy value to 68% confidence.
+    if (zpp_ind.horCircularConfidence_valid)
+    {
+        scaleAccuracyTo68PercentConfidence(zpp_ind.horCircularConfidence,zppLoc);
+    }
+
+    if (zpp_ind.altitudeWrtEllipsoid_valid) {
+        zppLoc.flags |= GPS_LOCATION_HAS_ALTITUDE;
+        zppLoc.altitude = zpp_ind.altitudeWrtEllipsoid;
+    }
+
+    return LOC_API_ADAPTER_ERR_SUCCESS;
+}
+
+enum loc_api_adapter_err LocApiV02 :: getBestAvailableZppFix(GpsLocation & zppLoc)
+{
+    LocPosTechMask tech_mask;
+    return getBestAvailableZppFix(zppLoc, tech_mask);
+}
+
+enum loc_api_adapter_err LocApiV02 ::
+getBestAvailableZppFix(GpsLocation &zppLoc, LocPosTechMask &tech_mask)
+{
+    locClientReqUnionType req_union;
+
+    qmiLocGetBestAvailablePositionIndMsgT_v02 zpp_ind;
+    qmiLocGetBestAvailablePositionReqMsgT_v02 zpp_req;
+
+    memset(&zpp_ind, 0, sizeof(zpp_ind));
+    memset(&zpp_req, 0, sizeof(zpp_req));
+    memset(&zppLoc, 0, sizeof(zppLoc));
+    tech_mask = LOC_POS_TECH_MASK_DEFAULT;
+
+    req_union.pGetBestAvailablePositionReq = &zpp_req;
+
+    LOC_LOGD("%s:%d]: Get ZPP Fix from best available source\n", __func__, __LINE__);
+
+    locClientStatusEnumType status =
+        loc_sync_send_req(clientHandle,
+                          QMI_LOC_GET_BEST_AVAILABLE_POSITION_REQ_V02,
+                          req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT,
+                          QMI_LOC_GET_BEST_AVAILABLE_POSITION_IND_V02,
+                          &zpp_ind);
+
+    if (status != eLOC_CLIENT_SUCCESS ||
+        eQMI_LOC_SUCCESS_V02 != zpp_ind.status) {
+        LOC_LOGE ("%s:%d]: error! status = %s, zpp_ind.status = %s\n",
+                  __func__, __LINE__,
+                  loc_get_v02_client_status_name(status),
+                  loc_get_v02_qmi_status_name(zpp_ind.status));
+    } else {
+        LOC_LOGD("Got Zpp fix location validity (lat:%d, lon:%d, timestamp:%d accuracy:%d)"
+                 " (%.7f, %.7f), timestamp %llu, accuracy %f",
+                 zpp_ind.latitude_valid,
+                 zpp_ind.longitude_valid,
+                 zpp_ind.timestampUtc_valid,
+                 zpp_ind.horUncCircular_valid,
+                 zpp_ind.latitude,
+                 zpp_ind.longitude,
+                 zpp_ind.timestampUtc,
+                 zpp_ind.horUncCircular);
+
+        zppLoc.size = sizeof(GpsLocation);
+        if (zpp_ind.timestampUtc_valid) {
+            zppLoc.timestamp = zpp_ind.timestampUtc;
+        }
+        else {
+            /* The UTC time from modem is not valid.
+            In this case, we use current system time instead.*/
+
+            struct timespec time_info_current;
+            clock_gettime(CLOCK_REALTIME,&time_info_current);
+            zppLoc.timestamp = (time_info_current.tv_sec)*1e3 +
+                               (time_info_current.tv_nsec)/1e6;
+            LOC_LOGD("zpp timestamp got from system: %llu", zppLoc.timestamp);
+        }
+
+        if (zpp_ind.latitude_valid &&
+            zpp_ind.longitude_valid &&
+            zpp_ind.horUncCircular_valid ) {
+            zppLoc.flags = GPS_LOCATION_HAS_LAT_LONG | GPS_LOCATION_HAS_ACCURACY;
+            zppLoc.latitude = zpp_ind.latitude;
+            zppLoc.longitude = zpp_ind.longitude;
+            zppLoc.accuracy = zpp_ind.horUncCircular;
+
+            // If horCircularConfidence_valid is true, and horCircularConfidence value
+            // is less than 68%, then scale the accuracy value to 68% confidence.
+            if (zpp_ind.horCircularConfidence_valid)
+            {
+                scaleAccuracyTo68PercentConfidence(zpp_ind.horCircularConfidence,
+                                                   zppLoc);
+            }
+
+            if (zpp_ind.altitudeWrtEllipsoid_valid) {
+                zppLoc.flags |= GPS_LOCATION_HAS_ALTITUDE;
+                zppLoc.altitude = zpp_ind.altitudeWrtEllipsoid;
+            }
+
+            if (zpp_ind.horSpeed_valid) {
+                zppLoc.flags |= GPS_LOCATION_HAS_SPEED;
+                zppLoc.speed = zpp_ind.horSpeed;
+            }
+
+            if (zpp_ind.heading_valid) {
+                zppLoc.flags |= GPS_LOCATION_HAS_BEARING;
+                zppLoc.bearing = zpp_ind.heading;
+            }
+
+            if (zpp_ind.technologyMask_valid) {
+                tech_mask = zpp_ind.technologyMask;
+            }
+        }
+    }
+
+    return convertErr(status);
+}
+
+/*Values for lock
+  1 = Do not lock any position sessions
+  2 = Lock MI position sessions
+  3 = Lock MT position sessions
+  4 = Lock all position sessions
+
+  Returns values:
+  zero on success; non-zero on failure
+*/
+int LocApiV02 :: setGpsLock(LOC_GPS_LOCK_MASK lockMask)
+{
+    qmiLocSetEngineLockReqMsgT_v02 setEngineLockReq;
+    qmiLocSetEngineLockIndMsgT_v02 setEngineLockInd;
+    locClientStatusEnumType status;
+    locClientReqUnionType req_union;
+    int ret=0;
+
+    LOC_LOGD("%s:%d]: Set Gps Lock: %x\n", __func__, __LINE__, lockMask);
+    setEngineLockReq.lockType = convertGpsLockMask(lockMask);
+    req_union.pSetEngineLockReq = &setEngineLockReq;
+    memset(&setEngineLockInd, 0, sizeof(setEngineLockInd));
+    status = loc_sync_send_req(clientHandle,
+                               QMI_LOC_SET_ENGINE_LOCK_REQ_V02,
+                               req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT,
+                               QMI_LOC_SET_ENGINE_LOCK_IND_V02,
+                               &setEngineLockInd);
+
+    if(status != eLOC_CLIENT_SUCCESS || setEngineLockInd.status != eQMI_LOC_SUCCESS_V02) {
+        LOC_LOGE("%s:%d]: Set engine lock failed. status: %s, ind status:%s\n",
+                 __func__, __LINE__,
+                 loc_get_v02_client_status_name(status),
+                 loc_get_v02_qmi_status_name(setEngineLockInd.status));
+        ret = -1;
+    }
+    LOC_LOGD("%s:%d]: exit\n", __func__, __LINE__);
+    return ret;
+}
+/*
+  Returns
+  Current value of GPS Lock on success
+  -1 on failure
+*/
+int LocApiV02 :: getGpsLock()
+{
+    qmiLocGetEngineLockReqMsgT_v02 getEngineLockReq;
+    qmiLocGetEngineLockIndMsgT_v02 getEngineLockInd;
+    locClientStatusEnumType status;
+    locClientReqUnionType req_union;
+    int ret=0;
+    LOC_LOGD("%s:%d]: Enter\n", __func__, __LINE__);
+    memset(&getEngineLockInd, 0, sizeof(getEngineLockInd));
+
+    //Passing req_union as a parameter even though this request has no payload
+    //since NULL or 0 gives an error during compilation
+    status = loc_sync_send_req(clientHandle,
+                               QMI_LOC_GET_ENGINE_LOCK_REQ_V02,
+                               req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT,
+                               QMI_LOC_GET_ENGINE_LOCK_IND_V02,
+                               &getEngineLockInd);
+    if(status != eLOC_CLIENT_SUCCESS || getEngineLockInd.status != eQMI_LOC_SUCCESS_V02) {
+        LOC_LOGE("%s:%d]: Set engine lock failed. status: %s, ind status:%s\n",
+                 __func__, __LINE__,
+                 loc_get_v02_client_status_name(status),
+                 loc_get_v02_qmi_status_name(getEngineLockInd.status));
+        ret = -1;
+    }
+    else {
+        if(getEngineLockInd.lockType_valid) {
+            ret = (int)getEngineLockInd.lockType;
+            LOC_LOGD("%s:%d]: Lock Type: %d\n", __func__, __LINE__, ret);
+        }
+        else {
+            LOC_LOGE("%s:%d]: Lock Type not valid\n", __func__, __LINE__);
+            ret = -1;
+        }
+    }
+    LOC_LOGD("%s:%d]: Exit\n", __func__, __LINE__);
+    return ret;
+}
+
+enum loc_api_adapter_err LocApiV02:: setXtraVersionCheck(enum xtra_version_check check)
+{
+    qmiLocSetXtraVersionCheckReqMsgT_v02 req;
+    qmiLocSetXtraVersionCheckIndMsgT_v02 ind;
+    locClientStatusEnumType status;
+    locClientReqUnionType req_union;
+    enum loc_api_adapter_err ret = LOC_API_ADAPTER_ERR_SUCCESS;
+
+    LOC_LOGD("%s:%d]: Enter. check: %d", __func__, __LINE__, check);
+    memset(&req, 0, sizeof(req));
+    memset(&ind, 0, sizeof(ind));
+    switch (check) {
+    case DISABLED:
+        req.xtraVersionCheckMode = eQMI_LOC_XTRA_VERSION_CHECK_DISABLE_V02;
+        break;
+    case AUTO:
+        req.xtraVersionCheckMode = eQMI_LOC_XTRA_VERSION_CHECK_AUTO_V02;
+        break;
+    case XTRA2:
+        req.xtraVersionCheckMode = eQMI_LOC_XTRA_VERSION_CHECK_XTRA2_V02;
+        break;
+    case XTRA3:
+        req.xtraVersionCheckMode = eQMI_LOC_XTRA_VERSION_CHECK_XTRA3_V02;
+        break;
+    default:
+        req.xtraVersionCheckMode = eQMI_LOC_XTRA_VERSION_CHECK_DISABLE_V02;
+        break;
+    }
+
+    req_union.pSetXtraVersionCheckReq = &req;
+    status = loc_sync_send_req(clientHandle,
+                               QMI_LOC_SET_XTRA_VERSION_CHECK_REQ_V02,
+                               req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT,
+                               QMI_LOC_SET_XTRA_VERSION_CHECK_IND_V02,
+                               &ind);
+    if(status != eLOC_CLIENT_SUCCESS || ind.status != eQMI_LOC_SUCCESS_V02) {
+        LOC_LOGE("%s:%d]: Set xtra version check failed. status: %s, ind status:%s\n",
+                 __func__, __LINE__,
+                 loc_get_v02_client_status_name(status),
+                 loc_get_v02_qmi_status_name(ind.status));
+        ret = LOC_API_ADAPTER_ERR_GENERAL_FAILURE;
+    }
+
+    LOC_LOGD("%s:%d]: Exit. ret: %d", __func__, __LINE__, (int)ret);
+    return ret;
+}
+
+void LocApiV02 :: installAGpsCert(const DerEncodedCertificate* pData,
+                                  size_t numberOfCerts,
+                                  uint32_t slotBitMask)
+{
+    LOC_LOGD("%s:%d]:, slot mask=%u number of certs=%u",
+            __func__, __LINE__, slotBitMask, numberOfCerts);
+
+    uint8_t certIndex = 0;
+    for (uint8_t slot = 0; slot <= AGPS_CERTIFICATE_MAX_SLOTS-1; slot++, slotBitMask >>= 1)
+    {
+        if (slotBitMask & 1) //slot is writable
+        {
+            if (certIndex < numberOfCerts && pData[certIndex].data && pData[certIndex].length > 0)
+            {
+                LOC_LOGD("%s:%d]:, Inject cert#%u slot=%u length=%u",
+                         __func__, __LINE__, certIndex, slot, pData[certIndex].length);
+
+                locClientReqUnionType req_union;
+                locClientStatusEnumType status;
+                qmiLocInjectSuplCertificateReqMsgT_v02 injectCertReq;
+                qmiLocInjectSuplCertificateIndMsgT_v02 injectCertInd;
+
+                memset(&injectCertReq, 0, sizeof(injectCertReq));
+                memset(&injectCertInd, 0, sizeof(injectCertInd));
+                injectCertReq.suplCertId = slot;
+                injectCertReq.suplCertData_len = pData[certIndex].length;
+                memcpy(injectCertReq.suplCertData, pData[certIndex].data, pData[certIndex].length);
+
+                req_union.pInjectSuplCertificateReq = &injectCertReq;
+
+                status = loc_sync_send_req(clientHandle,
+                                           QMI_LOC_INJECT_SUPL_CERTIFICATE_REQ_V02,
+                                           req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT,
+                                           QMI_LOC_INJECT_SUPL_CERTIFICATE_IND_V02,
+                                           &injectCertInd);
+
+                if (status != eLOC_CLIENT_SUCCESS ||
+                    eQMI_LOC_SUCCESS_V02 != injectCertInd.status)
+                {
+                    LOC_LOGE ("%s:%d]: inject-error status = %s, set_server_ind.status = %s",
+                              __func__,__LINE__,
+                              loc_get_v02_client_status_name(status),
+                              loc_get_v02_qmi_status_name(injectCertInd.status));
+                }
+
+                certIndex++; //move to next cert
+
+            } else {
+
+                LOC_LOGD("%s:%d]:, Delete slot=%u",
+                         __func__, __LINE__, slot);
+
+                // A fake cert is injected first before delete is called to workaround
+                // an issue that is seen with trying to delete an empty slot.
+                {
+                    locClientReqUnionType req_union;
+                    locClientStatusEnumType status;
+                    qmiLocInjectSuplCertificateReqMsgT_v02 injectFakeCertReq;
+                    qmiLocInjectSuplCertificateIndMsgT_v02 injectFakeCertInd;
+
+                    memset(&injectFakeCertReq, 0, sizeof(injectFakeCertReq));
+                    memset(&injectFakeCertInd, 0, sizeof(injectFakeCertInd));
+                    injectFakeCertReq.suplCertId = slot;
+                    injectFakeCertReq.suplCertData_len = 1;
+                    injectFakeCertReq.suplCertData[0] = 1;
+
+                    req_union.pInjectSuplCertificateReq = &injectFakeCertReq;
+
+                    status = loc_sync_send_req(clientHandle,
+                                       QMI_LOC_INJECT_SUPL_CERTIFICATE_REQ_V02,
+                                       req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT,
+                                       QMI_LOC_INJECT_SUPL_CERTIFICATE_IND_V02,
+                                       &injectFakeCertInd);
+
+                    if (status != eLOC_CLIENT_SUCCESS ||
+                        eQMI_LOC_SUCCESS_V02 != injectFakeCertInd.status)
+                    {
+                        LOC_LOGE ("%s:%d]: inject-fake-error status = %s, set_server_ind.status = %s",
+                                  __func__,__LINE__,
+                                  loc_get_v02_client_status_name(status),
+                                  loc_get_v02_qmi_status_name(injectFakeCertInd.status));
+                    }
+                }
+
+                locClientReqUnionType req_union;
+                locClientStatusEnumType status;
+                qmiLocDeleteSuplCertificateReqMsgT_v02 deleteCertReq;
+                qmiLocDeleteSuplCertificateIndMsgT_v02 deleteCertInd;
+
+                memset(&deleteCertReq, 0, sizeof(deleteCertReq));
+                memset(&deleteCertInd, 0, sizeof(deleteCertInd));
+                deleteCertReq.suplCertId = slot;
+                deleteCertReq.suplCertId_valid = 1;
+
+                req_union.pDeleteSuplCertificateReq = &deleteCertReq;
+
+                status = loc_sync_send_req(clientHandle,
+                                           QMI_LOC_DELETE_SUPL_CERTIFICATE_REQ_V02,
+                                           req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT,
+                                           QMI_LOC_DELETE_SUPL_CERTIFICATE_IND_V02,
+                                           &deleteCertInd);
+
+                if (status != eLOC_CLIENT_SUCCESS ||
+                    eQMI_LOC_SUCCESS_V02 != deleteCertInd.status)
+                {
+                    LOC_LOGE("%s:%d]: delete-error status = %s, set_server_ind.status = %s",
+                              __func__,__LINE__,
+                              loc_get_v02_client_status_name(status),
+                              loc_get_v02_qmi_status_name(deleteCertInd.status));
+                }
+            }
+        } else {
+            LOC_LOGD("%s:%d]:, Not writable slot=%u",
+                     __func__, __LINE__, slot);
+        }
+    }
+}
+
+int LocApiV02::setSvMeasurementConstellation(const qmiLocGNSSConstellEnumT_v02 svConstellation)
+{
+    enum loc_api_adapter_err ret_val = LOC_API_ADAPTER_ERR_SUCCESS;
+    qmiLocSetGNSSConstRepConfigReqMsgT_v02 setGNSSConstRepConfigReq;
+    qmiLocSetGNSSConstRepConfigIndMsgT_v02 setGNSSConstRepConfigInd;
+    locClientStatusEnumType status;
+    locClientReqUnionType req_union;
+    LOC_LOGD("%s] set GNSS measurement to report constellation: %lld\n",
+            __func__, svConstellation);
+
+    memset(&setGNSSConstRepConfigReq, 0, sizeof(setGNSSConstRepConfigReq));
+    setGNSSConstRepConfigReq.measReportConfig_valid = true;
+    setGNSSConstRepConfigReq.measReportConfig = svConstellation;
+    setGNSSConstRepConfigReq.svPolyReportConfig_valid = true;
+    setGNSSConstRepConfigReq.svPolyReportConfig = svConstellation;
+
+    req_union.pSetGNSSConstRepConfigReq = &setGNSSConstRepConfigReq;
+    memset(&setGNSSConstRepConfigInd, 0, sizeof(setGNSSConstRepConfigInd));
+
+    status = loc_sync_send_req(clientHandle,
+                                QMI_LOC_SET_GNSS_CONSTELL_REPORT_CONFIG_V02,
+                                req_union,
+                                LOC_ENGINE_SYNC_REQUEST_TIMEOUT,
+                                QMI_LOC_SET_GNSS_CONSTELL_REPORT_CONFIG_IND_V02,
+                                &setGNSSConstRepConfigInd);
+
+    if(status != eLOC_CLIENT_SUCCESS || setGNSSConstRepConfigInd.status != eQMI_LOC_SUCCESS_V02)
+    {
+        LOC_LOGE("%s:%d]: Set GNSS constellation failed. status: %s, ind status:%s\n",
+                __func__, __LINE__,
+                loc_get_v02_client_status_name(status),
+                loc_get_v02_qmi_status_name(setGNSSConstRepConfigInd.status));
+        ret_val = LOC_API_ADAPTER_ERR_GENERAL_FAILURE;
+    } else {
+        LOC_LOGD("%s:%d]: Set GNSS constellation succeeded.\n",
+                __func__, __LINE__);
+    }
+
+    return ret_val;
+}
+
+bool LocApiV02 :: gnssConstellationConfig()
+{
+    return mGnssMeasurementSupported == sup_yes;
+}
+
+void LocApiV02 :: cacheGnssMeasurementSupport()
+{
+    if (sup_unknown == mGnssMeasurementSupported) {
+        if ((mQmiMask & QMI_LOC_EVENT_MASK_POSITION_REPORT_V02) ==
+            QMI_LOC_EVENT_MASK_POSITION_REPORT_V02) {
+            /*for GNSS Measurement service, use
+              QMI_LOC_SET_GNSS_CONSTELL_REPORT_CONFIG_V02
+              to check if modem support this feature or not*/
+            LOC_LOGD("%s:%d]: set GNSS measurement to report gps measurement only.\n",
+                     __func__, __LINE__);
+
+            qmiLocSetGNSSConstRepConfigReqMsgT_v02 setGNSSConstRepConfigReq;
+            qmiLocSetGNSSConstRepConfigIndMsgT_v02 setGNSSConstRepConfigInd;
+            memset(&setGNSSConstRepConfigReq, 0, sizeof(setGNSSConstRepConfigReq));
+            memset(&setGNSSConstRepConfigInd, 0, sizeof(setGNSSConstRepConfigInd));
+
+            locClientStatusEnumType status;
+            locClientReqUnionType req_union;
+
+            setGNSSConstRepConfigReq.measReportConfig_valid = true;
+            setGNSSConstRepConfigReq.measReportConfig = eQMI_SYSTEM_GPS_V02;
+            req_union.pSetGNSSConstRepConfigReq = &setGNSSConstRepConfigReq;
+
+            status = loc_sync_send_req(clientHandle,
+                                       QMI_LOC_SET_GNSS_CONSTELL_REPORT_CONFIG_V02,
+                                       req_union,
+                                       LOC_ENGINE_SYNC_REQUEST_TIMEOUT,
+                                       QMI_LOC_SET_GNSS_CONSTELL_REPORT_CONFIG_IND_V02,
+                                       &setGNSSConstRepConfigInd);
+
+            if(status != eLOC_CLIENT_SUCCESS ||
+               setGNSSConstRepConfigInd.status != eQMI_LOC_SUCCESS_V02) {
+                LOC_LOGD("%s:%d]: Set GNSS constellation failed."
+                         " status: %s, ind status:%s\n",
+                         __func__, __LINE__,
+                         loc_get_v02_client_status_name(status),
+                         loc_get_v02_qmi_status_name(setGNSSConstRepConfigInd.status));
+                mGnssMeasurementSupported = sup_no;
+            } else {
+                LOC_LOGD("%s:%d]: Set GNSS constellation succeeded.\n",
+                         __func__, __LINE__);
+                mGnssMeasurementSupported = sup_yes;
+            }
+        }
+    }
+
+    LOC_LOGV("%s:%d]: mGnssMeasurementSupported is %d\n", __func__, __LINE__, mGnssMeasurementSupported);
+}
diff --git a/gps/loc_api/loc_api_v02/LocApiV02.h b/gps/loc_api/loc_api_v02/LocApiV02.h
new file mode 100644
index 0000000..1c31b34
--- /dev/null
+++ b/gps/loc_api/loc_api_v02/LocApiV02.h
@@ -0,0 +1,262 @@
+/* Copyright (c) 2011-2016, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of The Linux Foundation, nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef LOC_API_V_0_2_H
+#define LOC_API_V_0_2_H
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <ds_client.h>
+#include <LocApiBase.h>
+#include <loc_api_v02_client.h>
+
+using namespace loc_core;
+
+/* This class derives from the LocApiBase class.
+   The members of this class are responsible for converting
+   the Loc API V02 data structures into Loc Adapter data structures.
+   This class also implements some of the virtual functions that
+   handle the requests from loc engine. */
+class LocApiV02 : public LocApiBase {
+  enum supported_status {
+      sup_unknown,
+      sup_yes,
+      sup_no
+  };
+protected:
+  /* loc api v02 handle*/
+  locClientHandleType clientHandle;
+
+private:
+  /* ds client library handle */
+  void *dsLibraryHandle;
+  /* ds client interface */
+  const ds_client_iface_type *dsClientIface;
+  /* ds client handle */
+  dsClientHandleType dsClientHandle;
+  enum supported_status mGnssMeasurementSupported;
+  locClientEventMaskType mQmiMask;
+  bool mInSession;
+  bool mEngineOn;
+  bool mMeasurementsStarted;
+
+  /* Convert event mask from loc eng to loc_api_v02 format */
+  static locClientEventMaskType convertMask(LOC_API_ADAPTER_EVENT_MASK_T mask);
+
+  /* Convert GPS LOCK mask from gps.conf definition */
+  static qmiLocLockEnumT_v02 convertGpsLockMask(LOC_GPS_LOCK_MASK lockMask);
+
+  /* Convert error from loc_api_v02 to loc eng format*/
+  static enum loc_api_adapter_err convertErr(locClientStatusEnumType status);
+
+  /* convert Ni Encoding type from QMI_LOC to loc eng format */
+  static GpsNiEncodingType convertNiEncoding(
+    qmiLocNiDataCodingSchemeEnumT_v02 loc_encoding);
+
+  /*convert NI notify verify type from QMI LOC to loc eng format*/
+  static bool convertNiNotifyVerifyType (GpsNiNotification *notif,
+      qmiLocNiNotifyVerifyEnumT_v02 notif_priv);
+
+  /*convert GnssMeasurement type from QMI LOC to loc eng format*/
+  static void convertGnssMeasurements (GnssMeasurement& gnssMeasurement,
+      const qmiLocSVMeasurementStructT_v02& gnss_measurement_info);
+
+  /*convert GnssClock type from QMI LOC to loc eng format*/
+  void convertGnssClock (GnssClock& gnssClock,
+      const qmiLocEventGnssSvMeasInfoIndMsgT_v02& gnss_measurement_info);
+
+  /* If Confidence value is less than 68%, then scale the accuracy value to 68%
+     confidence.*/
+  void scaleAccuracyTo68PercentConfidence(const uint8_t confidenceValue,
+                                          GpsLocation &gpsLocation);
+
+  /* convert position report to loc eng format and send the converted
+     position to loc eng */
+  void reportPosition
+    (const qmiLocEventPositionReportIndMsgT_v02 *location_report_ptr);
+
+  /* convert satellite report to loc eng format and  send the converted
+     report to loc eng */
+  void reportSv (const qmiLocEventGnssSvInfoIndMsgT_v02 *gnss_report_ptr);
+
+  void reportSvMeasurement (
+  const qmiLocEventGnssSvMeasInfoIndMsgT_v02 *gnss_raw_measurement_ptr);
+
+  void  reportSvPolynomial (
+  const qmiLocEventGnssSvPolyIndMsgT_v02 *gnss_sv_poly_ptr);
+
+  /* convert engine state report to loc eng format and send the converted
+     report to loc eng */
+  void reportEngineState (
+    const qmiLocEventEngineStateIndMsgT_v02 *engine_state_ptr);
+
+  /* convert fix session report to loc eng format and send the converted
+     report to loc eng */
+  void reportFixSessionState (
+    const qmiLocEventFixSessionStateIndMsgT_v02 *fix_session_state_ptr);
+
+  /* convert NMEA report to loc eng format and send the converted
+     report to loc eng */
+  void reportNmea (const qmiLocEventNmeaIndMsgT_v02 *nmea_report_ptr);
+
+  /* convert and report an ATL request to loc engine */
+  void reportAtlRequest(
+    const qmiLocEventLocationServerConnectionReqIndMsgT_v02
+    *server_request_ptr);
+
+  /* convert and report NI request to loc eng */
+  void reportNiRequest(
+    const qmiLocEventNiNotifyVerifyReqIndMsgT_v02 *ni_req_ptr);
+
+  /* report the xtra server info */
+  void reportXtraServerUrl(
+    const qmiLocEventInjectPredictedOrbitsReqIndMsgT_v02* server_request_ptr);
+
+  /* convert and report GNSS measurement data to loc eng */
+  void reportGnssMeasurementData(
+    const qmiLocEventGnssSvMeasInfoIndMsgT_v02& gnss_measurement_report_ptr);
+
+  bool registerEventMask(locClientEventMaskType qmiMask);
+  locClientEventMaskType adjustMaskForNoSession(locClientEventMaskType qmiMask);
+  void cacheGnssMeasurementSupport();
+
+protected:
+  virtual enum loc_api_adapter_err
+    open(LOC_API_ADAPTER_EVENT_MASK_T mask);
+  virtual enum loc_api_adapter_err
+    close();
+
+  LocApiV02(const MsgTask* msgTask,
+            LOC_API_ADAPTER_EVENT_MASK_T exMask,
+            ContextBase *context = NULL);
+public:
+  ~LocApiV02();
+
+  static LocApiBase* createLocApiV02(const MsgTask *msgTask,
+                                  LOC_API_ADAPTER_EVENT_MASK_T exMask,
+                                  ContextBase* context);
+  /* event callback registered with the loc_api v02 interface */
+  virtual void eventCb(locClientHandleType client_handle,
+               uint32_t loc_event_id,
+               locClientEventIndUnionType loc_event_payload);
+
+  /* error callback, this function handles the  service unavailable
+     error */
+  void errorCb(locClientHandleType handle,
+               locClientErrorEnumType errorId);
+
+  void ds_client_event_cb(ds_client_status_enum_type result);
+
+  virtual enum loc_api_adapter_err startFix(const LocPosMode& posMode);
+
+  virtual enum loc_api_adapter_err stopFix();
+
+  virtual enum loc_api_adapter_err
+    setPositionMode(const LocPosMode& mode);
+
+  virtual enum loc_api_adapter_err
+    setTime(GpsUtcTime time, int64_t timeReference, int uncertainty);
+
+  virtual enum loc_api_adapter_err
+    injectPosition(double latitude, double longitude, float accuracy);
+
+  virtual enum loc_api_adapter_err
+    deleteAidingData(GpsAidingData f);
+
+  virtual enum loc_api_adapter_err
+    informNiResponse(GpsUserResponseType userResponse,
+                     const void* passThroughData);
+
+  virtual enum loc_api_adapter_err
+    setServer(const char* url, int len);
+  virtual enum loc_api_adapter_err
+    setServer(unsigned int ip, int port, LocServerType type);
+  virtual enum loc_api_adapter_err
+    setXtraData(char* data, int length);
+  virtual enum loc_api_adapter_err
+    requestXtraServer();
+  virtual enum loc_api_adapter_err
+    atlOpenStatus(int handle, int is_succ, char* apn, AGpsBearerType bear,
+                   AGpsType agpsType);
+  virtual enum loc_api_adapter_err atlCloseStatus(int handle, int is_succ);
+  virtual enum loc_api_adapter_err setSUPLVersion(uint32_t version);
+
+  virtual enum loc_api_adapter_err setNMEATypes (uint32_t typesMask);
+
+  virtual enum loc_api_adapter_err setLPPConfig(uint32_t profile);
+
+  virtual enum loc_api_adapter_err
+    setSensorControlConfig(int sensorUsage, int sensorProvider);
+
+  virtual enum loc_api_adapter_err
+    setSensorProperties(bool gyroBiasVarianceRandomWalk_valid, float gyroBiasVarianceRandomWalk,
+                            bool accelBiasVarianceRandomWalk_valid, float accelBiasVarianceRandomWalk,
+                            bool angleBiasVarianceRandomWalk_valid, float angleBiasVarianceRandomWalk,
+                            bool rateBiasVarianceRandomWalk_valid, float rateBiasVarianceRandomWalk,
+                            bool velocityBiasVarianceRandomWalk_valid, float velocityBiasVarianceRandomWalk);
+
+  virtual enum loc_api_adapter_err
+    setSensorPerfControlConfig(int controlMode, int accelSamplesPerBatch, int accelBatchesPerSec,
+                               int gyroSamplesPerBatch, int gyroBatchesPerSec,
+                               int accelSamplesPerBatchHigh, int accelBatchesPerSecHigh,
+                               int gyroSamplesPerBatchHigh, int gyroBatchesPerSecHigh, int algorithmConfig);
+  virtual enum loc_api_adapter_err setAGLONASSProtocol(unsigned long aGlonassProtocol);
+  virtual enum loc_api_adapter_err setLPPeProtocol(unsigned long lppeCP, unsigned long lppeUP);
+  virtual enum loc_api_adapter_err
+      getWwanZppFix(GpsLocation & zppLoc);
+  virtual enum loc_api_adapter_err
+      getBestAvailableZppFix(GpsLocation & zppLoc);
+  virtual enum loc_api_adapter_err
+      getBestAvailableZppFix(GpsLocation & zppLoc, LocPosTechMask & tech_mask);
+  virtual int initDataServiceClient();
+  virtual int openAndStartDataCall();
+  virtual void stopDataCall();
+  virtual void closeDataCall();
+  virtual int setGpsLock(LOC_GPS_LOCK_MASK lock);
+
+  /*
+    Returns
+    Current value of GPS Lock on success
+    -1 on failure
+  */
+  virtual int getGpsLock(void);
+  virtual int setSvMeasurementConstellation(const qmiLocGNSSConstellEnumT_v02 svConstellation);
+  virtual enum loc_api_adapter_err setXtraVersionCheck(enum xtra_version_check check);
+  virtual void installAGpsCert(const DerEncodedCertificate* pData,
+                               size_t length,
+                               uint32_t slotBitMask);
+  /*
+    Set Gnss Constellation Config
+  */
+  virtual bool gnssConstellationConfig();
+};
+
+extern "C" LocApiBase* getLocApi(const MsgTask* msgTask,
+                                 LOC_API_ADAPTER_EVENT_MASK_T exMask,
+                                 ContextBase *context);
+#endif //LOC_API_V_0_2_H
diff --git a/gps/loc_api/loc_api_v02/Makefile.am b/gps/loc_api/loc_api_v02/Makefile.am
new file mode 100644
index 0000000..2308cd4
--- /dev/null
+++ b/gps/loc_api/loc_api_v02/Makefile.am
@@ -0,0 +1,42 @@
+AM_CFLAGS = \
+            ${QMIF_CFLAGS} \
+            -I../../utils \
+            -I../../platform_lib_abstractions \
+            -I../libloc_api_50001
+
+requiredlibs = \
+            ${QMIF_LIBS} \
+            ../libloc_api_50001/libloc_adapter_so.la \
+            ../../utils/libgps_utils_so.la
+
+h_sources = LocApiV02Adapter.h \
+            loc_util_log.h \
+            location_service_v02.h \
+            loc_api_sync_req.h \
+            loc_api_v02_client.h \
+            loc_api_v02_log.h
+
+c_sources = LocApiV02Adapter.cpp \
+            loc_api_v02_log.c \
+            loc_api_v02_client.c \
+            loc_api_sync_req.c \
+            location_service_v02.c
+
+library_includedir = $(pkgincludedir)
+library_include_HEADERS = $(h_sources)
+
+libloc_api_la_SOURCES = $(c_sources) $(h_sources)
+
+if USE_GLIB
+libloc_api_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@
+libloc_api_la_LDFLAGS = -lstdc++ -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
+libloc_api_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
+else
+libloc_api_la_CFLAGS = $(AM_CFLAGS)
+libloc_api_la_LDFLAGS = -shared -version-info 1:0:0
+libloc_api_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS)
+endif
+
+libloc_api_la_LIBADD = $(requiredlibs) -lstdc++
+
+lib_LTLIBRARIES = libloc_api.la
diff --git a/gps/loc_api/loc_api_v02/loc_api_sync_req.c b/gps/loc_api/loc_api_v02/loc_api_sync_req.c
new file mode 100644
index 0000000..1b2b69e
--- /dev/null
+++ b/gps/loc_api/loc_api_v02/loc_api_sync_req.c
@@ -0,0 +1,555 @@
+/* Copyright (c) 2011-2012, 2015-2016, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of The Linux Foundation, nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <stdio.h>
+#include <assert.h>
+#include <errno.h>
+#include <sys/time.h>
+#include <string.h>
+#include <pthread.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <loc_cfg.h>
+#include "loc_api_v02_client.h"
+#include "loc_api_sync_req.h"
+
+/* Logging */
+// Uncomment to log verbose logs
+#define LOG_NDEBUG 1
+
+// log debug logs
+#define LOG_NDDEBUG 1
+#define LOG_TAG "LocSvc_api_v02"
+#include "loc_util_log.h"
+
+#define LOC_SYNC_REQ_BUFFER_SIZE 8
+#define GPS_CONF_FILE "/etc/gps.conf"
+pthread_mutex_t  loc_sync_call_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+static bool loc_sync_call_initialized = false;
+
+typedef struct {
+   pthread_mutex_t         sync_req_lock;
+
+   /* Client ID */
+   locClientHandleType     client_handle;
+
+   /*  waiting conditional variable */
+   pthread_cond_t          ind_arrived_cond;
+
+   /* Callback waiting data block, protected by loc_cb_data_mutex */
+   bool                    ind_is_selected;              /* is cb selected? */
+   bool                    ind_is_waiting;               /* is waiting?     */
+   bool                    ind_has_arrived;              /* callback has arrived */
+   uint32_t                req_id;                    /*  sync request */
+   void                    *recv_ind_payload_ptr; /* received  payload */
+   uint32_t                recv_ind_id;      /* received  ind   */
+
+} loc_sync_req_data_s_type;
+
+typedef struct {
+   bool                        in_use;  /* at least one sync call is active */
+   bool                        slot_in_use[LOC_SYNC_REQ_BUFFER_SIZE];
+   loc_sync_req_data_s_type    slots[LOC_SYNC_REQ_BUFFER_SIZE];
+} loc_sync_req_array_s_type;
+
+/***************************************************************************
+ *                 DATA FOR ASYNCHRONOUS RPC PROCESSING
+ **************************************************************************/
+loc_sync_req_array_s_type loc_sync_array;
+
+/*===========================================================================
+
+FUNCTION   loc_sync_req_init
+
+DESCRIPTION
+   Initialize this module
+
+DEPENDENCIES
+   N/A
+
+RETURN VALUE
+   none
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+void loc_sync_req_init()
+{
+   LOC_LOGV(" %s:%d]:\n", __func__, __LINE__);
+   UTIL_READ_CONF_DEFAULT(GPS_CONF_FILE);
+   pthread_mutex_lock(&loc_sync_call_mutex);
+   if(true == loc_sync_call_initialized)
+   {
+      LOC_LOGD("%s:%d]:already initialized\n", __func__, __LINE__);
+      pthread_mutex_unlock(&loc_sync_call_mutex);
+      return;
+   }
+
+   loc_sync_array.in_use = false;
+
+   memset(loc_sync_array.slot_in_use, 0, sizeof(loc_sync_array.slot_in_use));
+
+   int i;
+   for (i = 0; i < LOC_SYNC_REQ_BUFFER_SIZE; i++)
+   {
+      loc_sync_req_data_s_type *slot = &loc_sync_array.slots[i];
+
+      pthread_mutex_init(&slot->sync_req_lock, NULL);
+      pthread_cond_init(&slot->ind_arrived_cond, NULL);
+
+      slot->client_handle = LOC_CLIENT_INVALID_HANDLE_VALUE;
+      slot->ind_is_selected = false;       /* is ind selected? */
+      slot->ind_is_waiting  = false;       /* is waiting?     */
+      slot->ind_has_arrived = false;       /* callback has arrived */
+      slot->recv_ind_id = 0;       /* ind to wait for   */
+      slot->recv_ind_payload_ptr = NULL;
+      slot->req_id =  0;   /* req id   */
+   }
+
+   loc_sync_call_initialized = true;
+   pthread_mutex_unlock(&loc_sync_call_mutex);
+}
+
+
+/*===========================================================================
+
+FUNCTION    loc_sync_process_ind
+
+DESCRIPTION
+   Wakes up blocked API calls to check if the needed callback has arrived
+
+DEPENDENCIES
+   N/A
+
+RETURN VALUE
+   none
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+void loc_sync_process_ind(
+      locClientHandleType    client_handle, /* handle of the client */
+      uint32_t               ind_id ,      /* ind id */
+      void                   *ind_payload_ptr, /* payload              */
+      uint32_t               ind_payload_size  /* payload size         */
+)
+{
+
+   LOC_LOGV("%s:%d]: received indication, handle = %p ind_id = %u \n",
+                 __func__,__LINE__, client_handle, ind_id);
+
+   pthread_mutex_lock(&loc_sync_call_mutex);
+
+   if (!loc_sync_array.in_use)
+   {
+      LOC_LOGD("%s:%d]: loc_sync_array not in use \n",
+                    __func__, __LINE__);
+      pthread_mutex_unlock(&loc_sync_call_mutex);
+      return;
+   }
+
+   bool in_use = false, consumed = false;
+   int i;
+
+   for (i = 0; i < LOC_SYNC_REQ_BUFFER_SIZE && !consumed; i++)
+   {
+      loc_sync_req_data_s_type *slot = &loc_sync_array.slots[i];
+
+      in_use |= loc_sync_array.slot_in_use[i];
+
+      pthread_mutex_lock(&slot->sync_req_lock);
+
+      if ( (loc_sync_array.slot_in_use[i]) && (slot->client_handle == client_handle)
+            && (ind_id == slot->recv_ind_id) && (!slot->ind_has_arrived))
+      {
+         LOC_LOGV("%s:%d]: found slot %d selected for ind %u \n",
+                       __func__, __LINE__, i, ind_id);
+
+         if( NULL != slot->recv_ind_payload_ptr &&
+                 NULL != ind_payload_ptr && ind_payload_size > 0 )
+         {
+            LOC_LOGV("%s:%d]: copying ind payload size = %zu \n",
+                          __func__, __LINE__, ind_payload_size);
+
+            memcpy(slot->recv_ind_payload_ptr, ind_payload_ptr, ind_payload_size);
+
+            consumed = true;
+         }
+         /* Received a callback while waiting, wake up thread to check it */
+         if (slot->ind_is_waiting)
+         {
+            slot->recv_ind_id = ind_id;
+
+            pthread_cond_signal(&slot->ind_arrived_cond);
+         }
+         else
+         {
+            /* If callback arrives before wait, remember it */
+            LOC_LOGV("%s:%d]: ind %u arrived before wait was called \n",
+                          __func__, __LINE__, ind_id);
+
+            slot->ind_has_arrived = true;
+         }
+      }
+      pthread_mutex_unlock(&slot->sync_req_lock);
+   }
+
+   if (!in_use) {
+      loc_sync_array.in_use = false;
+   }
+
+   pthread_mutex_unlock(&loc_sync_call_mutex);
+}
+
+/*===========================================================================
+
+FUNCTION    loc_alloc_slot
+
+DESCRIPTION
+   Allocates a buffer slot for the synchronous API call
+
+DEPENDENCIES
+   N/A
+
+RETURN VALUE
+   Select ID (>=0)     : successful
+   -1                  : buffer full
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+static int loc_alloc_slot()
+{
+   int i, select_id = -1; /* no free buffer */
+
+   pthread_mutex_lock(&loc_sync_call_mutex);
+
+   for (i = 0; i < LOC_SYNC_REQ_BUFFER_SIZE; i++)
+   {
+      if (!loc_sync_array.slot_in_use[i])
+      {
+         select_id = i;
+         loc_sync_array.slot_in_use[i] = 1;
+         loc_sync_array.in_use = true;
+         break;
+      }
+   }
+
+   pthread_mutex_unlock(&loc_sync_call_mutex);
+   LOC_LOGV("%s:%d]: returning slot %d\n",
+                 __func__, __LINE__, select_id);
+   return select_id;
+}
+
+/*===========================================================================
+
+FUNCTION    loc_free_slot
+
+DESCRIPTION
+   Frees a buffer slot after the synchronous API call
+
+DEPENDENCIES
+   N/A
+
+RETURN VALUE
+   None
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+static void loc_free_slot(int select_id)
+{
+   int i;
+   loc_sync_req_data_s_type *slot;
+
+   pthread_mutex_lock(&loc_sync_call_mutex);
+
+   LOC_LOGD("%s:%d]: freeing slot %d\n", __func__, __LINE__, select_id);
+
+   loc_sync_array.slot_in_use[select_id] = 0;
+
+   slot = &loc_sync_array.slots[select_id];
+
+   slot->client_handle = LOC_CLIENT_INVALID_HANDLE_VALUE;
+   slot->ind_is_selected = false;       /* is ind selected? */
+   slot->ind_is_waiting  = false;       /* is waiting?     */
+   slot->ind_has_arrived = false;       /* callback has arrived */
+   slot->recv_ind_id = 0;       /* ind to wait for   */
+   slot->recv_ind_payload_ptr = NULL;
+   slot->req_id =  0;
+
+   // check if all slots are now free
+   for (i = 0; i < LOC_SYNC_REQ_BUFFER_SIZE; i++)
+   {
+      if (loc_sync_array.slot_in_use[i]) break;
+   }
+
+   if (i >= LOC_SYNC_REQ_BUFFER_SIZE)
+   {
+      loc_sync_array.in_use = false;
+   }
+
+   pthread_mutex_unlock(&loc_sync_call_mutex);
+}
+
+/*===========================================================================
+
+FUNCTION    loc_sync_select_ind
+
+DESCRIPTION
+   Selects which indication to wait for.
+
+
+DEPENDENCIES
+   N/A
+
+RETURN VALUE
+   Select ID (>=0)     : successful
+   -ENOMEM                  : out of buffer
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+static int loc_sync_select_ind(
+      locClientHandleType       client_handle,   /* Client handle */
+      uint32_t                  ind_id,  /* ind Id wait for */
+      uint32_t                  req_id,   /* req id */
+      void *                    ind_payload_ptr /* ptr where payload should be copied to*/
+)
+{
+   int select_id = loc_alloc_slot();
+
+   LOC_LOGV("%s:%d]: client handle %p, ind_id %u, req_id %u \n",
+                 __func__, __LINE__, client_handle, ind_id, req_id);
+
+   if (select_id < 0)
+   {
+      LOC_LOGE("%s:%d]: buffer full for this synchronous req %s \n",
+                 __func__, __LINE__, loc_get_v02_event_name(req_id));
+      return -ENOMEM;
+   }
+
+   loc_sync_req_data_s_type *slot = &loc_sync_array.slots[select_id];
+
+   pthread_mutex_lock(&slot->sync_req_lock);
+
+   slot->client_handle = client_handle;
+   slot->ind_is_selected = true;
+   slot->ind_is_waiting = false;
+   slot->ind_has_arrived = false;
+
+   slot->recv_ind_id = ind_id;
+   slot->req_id      = req_id;
+   slot->recv_ind_payload_ptr = ind_payload_ptr; //store the payload ptr
+
+   pthread_mutex_unlock(&slot->sync_req_lock);
+
+   return select_id;
+}
+
+
+/*===========================================================================
+
+FUNCTION    loc_sync_wait_for_ind
+
+DESCRIPTION
+   Waits for a selected indication. The wait expires in timeout_seconds seconds.
+   If the function is called before an existing wait has finished, it will
+   immediately return error.
+
+DEPENDENCIES
+   N/A
+
+RETURN VALUE
+  0 on SUCCESS, -ve value on failure
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+static int loc_sync_wait_for_ind(
+      int select_id,        /* ID from loc_sync_select_ind() */
+      int timeout_seconds,  /* Timeout in this number of seconds  */
+      uint32_t ind_id
+)
+{
+   if (select_id < 0 || select_id >= LOC_SYNC_REQ_BUFFER_SIZE || !loc_sync_array.slot_in_use[select_id])
+   {
+      LOC_LOGE("%s:%d]: invalid select_id: %d \n",
+                    __func__, __LINE__, select_id);
+
+      return (-EINVAL);
+   }
+
+   loc_sync_req_data_s_type *slot = &loc_sync_array.slots[select_id];
+
+   int ret_val = 0;  /* the return value of this function: 0 = no error */
+   int rc;          /* return code from pthread calls */
+
+   struct timeval present_time;
+   struct timespec expire_time;
+
+   pthread_mutex_lock(&slot->sync_req_lock);
+
+  do
+  {
+      if (slot->ind_has_arrived)
+      {
+         ret_val = 0;    /* success */
+         break;
+      }
+
+      if (slot->ind_is_waiting)
+      {
+         LOC_LOGW("%s:%d]: already waiting in this slot %d\n", __func__,
+                       __LINE__, select_id);
+         ret_val = -EBUSY; // busy
+         break;
+      }
+
+      /* Calculate absolute expire time */
+      gettimeofday(&present_time, NULL);
+      expire_time.tv_sec  = present_time.tv_sec;
+      expire_time.tv_nsec = present_time.tv_usec * 1000;
+      expire_time.tv_sec += timeout_seconds;
+
+      /* Take new wait request */
+      slot->ind_is_waiting = true;
+
+      /* Waiting */
+      rc = pthread_cond_timedwait(&slot->ind_arrived_cond,
+            &slot->sync_req_lock, &expire_time);
+
+      slot->ind_is_waiting = false;
+
+      if(rc == ETIMEDOUT)
+      {
+         LOC_LOGE("%s:%d]: slot %d, timed out for ind_id %s\n",
+                    __func__, __LINE__, select_id, loc_get_v02_event_name(ind_id));
+         ret_val = -ETIMEDOUT; //time out
+      }
+
+  } while (0);
+
+   pthread_mutex_unlock(&slot->sync_req_lock);
+   loc_free_slot(select_id);
+
+   return ret_val;
+}
+
+/*===========================================================================
+
+FUNCTION    loc_sync_send_req
+
+DESCRIPTION
+   Synchronous req call (thread safe)
+
+DEPENDENCIES
+   N/A
+
+RETURN VALUE
+   Loc API 2.0 status
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+locClientStatusEnumType loc_sync_send_req
+(
+      locClientHandleType       client_handle,
+      uint32_t                  req_id,        /* req id */
+      locClientReqUnionType     req_payload,
+      uint32_t                  timeout_msec,
+      uint32_t                  ind_id,  //ind ID to block for, usually the same as req_id */
+      void                      *ind_payload_ptr /* can be NULL*/
+)
+{
+   locClientStatusEnumType status = eLOC_CLIENT_SUCCESS ;
+   int select_id;
+   int rc = 0;
+   int sendReqRetryRem = 5; // Number of retries remaining
+
+   // Select the callback we are waiting for
+   select_id = loc_sync_select_ind(client_handle, ind_id, req_id,
+                                   ind_payload_ptr);
+
+   if (select_id >= 0)
+   {
+      // Loop to retry few times in case of failures
+      do
+      {
+         status =  locClientSendReq (client_handle, req_id, req_payload);
+         LOC_LOGV("%s:%d]: select_id = %d,locClientSendReq returned %d\n",
+                       __func__, __LINE__, select_id, status);
+
+         if (status == eLOC_CLIENT_SUCCESS )
+         {
+            // Wait for the indication callback
+            if (( rc = loc_sync_wait_for_ind( select_id,
+                                              timeout_msec / 1000,
+                                              ind_id) ) < 0)
+            {
+               if ( rc == -ETIMEDOUT)
+                  status = eLOC_CLIENT_FAILURE_TIMEOUT;
+               else
+                  status = eLOC_CLIENT_FAILURE_INTERNAL;
+
+               // Callback waiting failed
+               LOC_LOGE("%s:%d]: loc_api_wait_for_ind failed, err %d, "
+                        "select id %d, status %s", __func__, __LINE__, rc ,
+                        select_id, loc_get_v02_client_status_name(status));
+            }
+            else
+            {
+               status =  eLOC_CLIENT_SUCCESS;
+               LOC_LOGV("%s:%d]: success (select id %d)\n",
+                             __func__, __LINE__, select_id);
+            }
+         }
+
+      } while(( status == eLOC_CLIENT_FAILURE_ENGINE_BUSY ||
+                    status == eLOC_CLIENT_FAILURE_PHONE_OFFLINE ||
+                    status == eLOC_CLIENT_FAILURE_INTERNAL ) &&
+                sendReqRetryRem-- > 0);
+
+      if (status != eLOC_CLIENT_SUCCESS )
+      {
+         loc_free_slot(select_id);
+      }
+
+   } /* select id */
+
+   return status;
+}
+
+
diff --git a/gps/loc_api/loc_api_v02/loc_api_sync_req.h b/gps/loc_api/loc_api_v02/loc_api_sync_req.h
new file mode 100644
index 0000000..b7908f8
--- /dev/null
+++ b/gps/loc_api/loc_api_v02/loc_api_sync_req.h
@@ -0,0 +1,92 @@
+/* Copyright (c) 2011,2013,2016, The Linux Foundation. All rights reserved
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of The Linux Foundation nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef LOC_SYNC_REQ_H
+#define LOC_SYNC_REQ_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+#include <stdbool.h>
+#include <stdint.h>
+#include "loc_api_v02_client.h"
+
+#define LOC_ENGINE_SYNC_REQUEST_TIMEOUT  (1000) // 1 second
+
+#define LOC_SEND_SYNC_REQ(NAME, ID, REQ, HANDLE)  \
+    int rv = true; \
+    locClientStatusEnumType st; \
+    locClientReqUnionType reqUnion; \
+    qmiLoc##NAME##IndMsgT_v02 ind; \
+\
+    memset(&ind, 0, sizeof(ind)); \
+    reqUnion.p##NAME##Req = &REQ; \
+\
+    st = loc_sync_send_req(HANDLE,                          \
+                           QMI_LOC_##ID##_REQ_V02,          \
+                           reqUnion,                        \
+                           LOC_ENGINE_SYNC_REQUEST_TIMEOUT, \
+                           QMI_LOC_##ID##_IND_V02,          \
+                           &ind);                           \
+\
+    if (st != eLOC_CLIENT_SUCCESS || \
+        eQMI_LOC_SUCCESS_V02 != ind.status) { \
+        LOC_LOGE ("%s:%d]: Error : st = %d, ind.status = %d", \
+                  __func__, __LINE__,  st, ind.status); \
+        rv = false; \
+    }
+
+/* Init function */
+extern void loc_sync_req_init();
+
+
+/* Process Loc API indications to wake up blocked user threads */
+extern void loc_sync_process_ind(
+      locClientHandleType     client_handle,     /* handle of the client */
+      uint32_t                ind_id ,      /* respInd id */
+      void                    *ind_payload_ptr, /* payload              */
+      uint32_t                ind_payload_size  /* payload size */
+);
+
+/* Thread safe synchronous request,  using Loc API status return code */
+extern locClientStatusEnumType loc_sync_send_req
+(
+      locClientHandleType       client_handle,
+      uint32_t                  req_id,        /* req id */
+      locClientReqUnionType     req_payload,
+      uint32_t                  timeout_msec,
+      uint32_t                  ind_id,  //ind ID to block for, usually the same as req_id */
+      void                      *ind_payload_ptr /* can be NULL*/
+);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LOC_SYNC_REQ_H */
diff --git a/gps/loc_api/loc_api_v02/loc_api_v02_client.c b/gps/loc_api/loc_api_v02/loc_api_v02_client.c
new file mode 100644
index 0000000..2ff0fbc
--- /dev/null
+++ b/gps/loc_api/loc_api_v02/loc_api_v02_client.c
@@ -0,0 +1,2303 @@
+/* Copyright (c) 2011-2016, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of The Linux Foundation, nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <stddef.h>
+
+#include <stdbool.h>
+#include <inttypes.h>
+
+#include "qmi_client.h"
+#include "qmi_idl_lib.h"
+#include "qmi_cci_target_ext.h"
+
+#if defined( _ANDROID_)
+#include "qmi_cci_target.h"
+#include "qmi_cci_common.h"
+#define LOG_NDEBUG 0
+#define LOG_TAG "LocSvc_api_v02"
+#endif //_ANDROID_
+
+
+#include "loc_api_v02_client.h"
+#include "loc_util_log.h"
+
+#ifdef LOC_UTIL_TARGET_OFF_TARGET
+
+// timeout in ms before send_msg_sync should return
+#define LOC_CLIENT_ACK_TIMEOUT (5000)
+
+#else
+
+// timeout in ms before send_msg_sync should return
+#define LOC_CLIENT_ACK_TIMEOUT (1000)
+
+#endif //LOC_UTIL_TARGET_OFF_TARGET
+
+#define LOC_CLIENT_MAX_OPEN_RETRIES (20)
+#define LOC_CLIENT_TIME_BETWEEN_OPEN_RETRIES (1)
+
+enum
+{
+  //! Special value for selecting any available service
+  /** This value enables selection of any available service */
+  eLOC_CLIENT_INSTANCE_ID_ANY = -1,
+  //! qca1530 service id value
+  /** qca1530 service daemon uses service id value 1 */
+  eLOC_CLIENT_INSTANCE_ID_QCA1530 = 1,
+  //! GSS service id value
+  /* GSS service id value is 0, but here it is set to -1 for compatibitily */
+  eLOC_CLIENT_INSTANCE_ID_GSS = eLOC_CLIENT_INSTANCE_ID_ANY,
+  //! MSM service id value
+  /** MSM service id value is 0, but here it is set to -1 for compatibitily */
+  eLOC_CLIENT_INSTANCE_ID_MSM = eLOC_CLIENT_INSTANCE_ID_ANY,
+  //! MDM service id value
+  /** MDM connects using QMUXD and assigned a value of
+      QMI_CLIENT_QMUX_RMNET_USB_INSTANCE_0 ("qmi_client_instance_defs.h", 37).
+      -1 for compatibility */
+  eLOC_CLIENT_INSTANCE_ID_MDM = eLOC_CLIENT_INSTANCE_ID_ANY,
+  /*  GSS service id value is 0, for auto config  */
+  eLOC_CLIENT_INSTANCE_ID_GSS_AUTO = 0
+};
+
+/* Table to relate eventId, size and mask value used to enable the event*/
+typedef struct
+{
+  uint32_t               eventId;
+  size_t                 eventSize;
+  locClientEventMaskType eventMask;
+}locClientEventIndTableStructT;
+
+
+static const locClientEventIndTableStructT locClientEventIndTable[]= {
+
+  // position report ind
+  { QMI_LOC_EVENT_POSITION_REPORT_IND_V02,
+    sizeof(qmiLocEventPositionReportIndMsgT_v02),
+    QMI_LOC_EVENT_MASK_POSITION_REPORT_V02 },
+
+  // satellite report ind
+  { QMI_LOC_EVENT_GNSS_SV_INFO_IND_V02,
+    sizeof(qmiLocEventGnssSvInfoIndMsgT_v02),
+    QMI_LOC_EVENT_MASK_GNSS_SV_INFO_V02 },
+
+  // NMEA report ind
+  { QMI_LOC_EVENT_NMEA_IND_V02,
+    sizeof(qmiLocEventNmeaIndMsgT_v02),
+    QMI_LOC_EVENT_MASK_NMEA_V02 },
+
+  //NI event ind
+  { QMI_LOC_EVENT_NI_NOTIFY_VERIFY_REQ_IND_V02,
+    sizeof(qmiLocEventNiNotifyVerifyReqIndMsgT_v02),
+    QMI_LOC_EVENT_MASK_NI_NOTIFY_VERIFY_REQ_V02 },
+
+  //Time Injection Request Ind
+  { QMI_LOC_EVENT_INJECT_TIME_REQ_IND_V02,
+    sizeof(qmiLocEventInjectTimeReqIndMsgT_v02),
+    QMI_LOC_EVENT_MASK_INJECT_TIME_REQ_V02 },
+
+  //Predicted Orbits Injection Request
+  { QMI_LOC_EVENT_INJECT_PREDICTED_ORBITS_REQ_IND_V02,
+    sizeof(qmiLocEventInjectPredictedOrbitsReqIndMsgT_v02),
+    QMI_LOC_EVENT_MASK_INJECT_PREDICTED_ORBITS_REQ_V02 },
+
+  //Position Injection Request Ind
+  { QMI_LOC_EVENT_INJECT_POSITION_REQ_IND_V02,
+    sizeof(qmiLocEventInjectPositionReqIndMsgT_v02),
+    QMI_LOC_EVENT_MASK_INJECT_POSITION_REQ_V02 } ,
+
+  //Engine State Report Ind
+  { QMI_LOC_EVENT_ENGINE_STATE_IND_V02,
+    sizeof(qmiLocEventEngineStateIndMsgT_v02),
+    QMI_LOC_EVENT_MASK_ENGINE_STATE_V02 },
+
+  //Fix Session State Report Ind
+  { QMI_LOC_EVENT_FIX_SESSION_STATE_IND_V02,
+    sizeof(qmiLocEventFixSessionStateIndMsgT_v02),
+    QMI_LOC_EVENT_MASK_FIX_SESSION_STATE_V02 },
+
+  //Wifi Request Indication
+  { QMI_LOC_EVENT_WIFI_REQ_IND_V02,
+    sizeof(qmiLocEventWifiReqIndMsgT_v02),
+    QMI_LOC_EVENT_MASK_WIFI_REQ_V02 },
+
+  //Sensor Streaming Ready Status Ind
+  { QMI_LOC_EVENT_SENSOR_STREAMING_READY_STATUS_IND_V02,
+    sizeof(qmiLocEventSensorStreamingReadyStatusIndMsgT_v02),
+    QMI_LOC_EVENT_MASK_SENSOR_STREAMING_READY_STATUS_V02 },
+
+  // Time Sync Request Indication
+  { QMI_LOC_EVENT_TIME_SYNC_REQ_IND_V02,
+    sizeof(qmiLocEventTimeSyncReqIndMsgT_v02),
+    QMI_LOC_EVENT_MASK_TIME_SYNC_REQ_V02 },
+
+  //Set Spi Streaming Report Event
+  { QMI_LOC_EVENT_SET_SPI_STREAMING_REPORT_IND_V02,
+    sizeof(qmiLocEventSetSpiStreamingReportIndMsgT_v02),
+    QMI_LOC_EVENT_MASK_SET_SPI_STREAMING_REPORT_V02 },
+
+  //Location Server Connection Request event
+  { QMI_LOC_EVENT_LOCATION_SERVER_CONNECTION_REQ_IND_V02,
+    sizeof(qmiLocEventLocationServerConnectionReqIndMsgT_v02),
+    QMI_LOC_EVENT_MASK_LOCATION_SERVER_CONNECTION_REQ_V02 },
+
+  // NI Geofence Event
+  { QMI_LOC_EVENT_NI_GEOFENCE_NOTIFICATION_IND_V02,
+    sizeof(qmiLocEventNiGeofenceNotificationIndMsgT_v02),
+    QMI_LOC_EVENT_MASK_NI_GEOFENCE_NOTIFICATION_V02},
+
+  // Geofence General Alert Event
+  { QMI_LOC_EVENT_GEOFENCE_GEN_ALERT_IND_V02,
+    sizeof(qmiLocEventGeofenceGenAlertIndMsgT_v02),
+    QMI_LOC_EVENT_MASK_GEOFENCE_GEN_ALERT_V02},
+
+  //Geofence Breach event
+  { QMI_LOC_EVENT_GEOFENCE_BREACH_NOTIFICATION_IND_V02,
+    sizeof(qmiLocEventGeofenceBreachIndMsgT_v02),
+    QMI_LOC_EVENT_MASK_GEOFENCE_BREACH_NOTIFICATION_V02},
+
+  //Geofence Batched Breach event
+  { QMI_LOC_EVENT_GEOFENCE_BATCHED_BREACH_NOTIFICATION_IND_V02,
+    sizeof(qmiLocEventGeofenceBatchedBreachIndMsgT_v02),
+    QMI_LOC_EVENT_MASK_GEOFENCE_BATCH_BREACH_NOTIFICATION_V02},
+
+  //Pedometer Control event
+  { QMI_LOC_EVENT_PEDOMETER_CONTROL_IND_V02,
+    sizeof(qmiLocEventPedometerControlIndMsgT_v02),
+    QMI_LOC_EVENT_MASK_PEDOMETER_CONTROL_V02 },
+
+  //Motion Data Control event
+  { QMI_LOC_EVENT_MOTION_DATA_CONTROL_IND_V02,
+    sizeof(qmiLocEventMotionDataControlIndMsgT_v02),
+    QMI_LOC_EVENT_MASK_MOTION_DATA_CONTROL_V02 },
+
+  //Wifi AP data request event
+  { QMI_LOC_EVENT_INJECT_WIFI_AP_DATA_REQ_IND_V02,
+    sizeof(qmiLocEventInjectWifiApDataReqIndMsgT_v02),
+    QMI_LOC_EVENT_MASK_INJECT_WIFI_AP_DATA_REQ_V02 },
+
+  //Get Batching On Fix Event
+  { QMI_LOC_EVENT_LIVE_BATCHED_POSITION_REPORT_IND_V02,
+    sizeof(qmiLocEventLiveBatchedPositionReportIndMsgT_v02),
+    QMI_LOC_EVENT_MASK_LIVE_BATCHED_POSITION_REPORT_V02 },
+
+  //Get Batching On Full Event
+  { QMI_LOC_EVENT_BATCH_FULL_NOTIFICATION_IND_V02,
+    sizeof(qmiLocEventBatchFullIndMsgT_v02),
+    QMI_LOC_EVENT_MASK_BATCH_FULL_NOTIFICATION_V02 },
+
+   //Vehicle Data Readiness event
+   { QMI_LOC_EVENT_VEHICLE_DATA_READY_STATUS_IND_V02,
+     sizeof(qmiLocEventVehicleDataReadyIndMsgT_v02),
+     QMI_LOC_EVENT_MASK_VEHICLE_DATA_READY_STATUS_V02 },
+
+  //Geofence Proximity event
+  { QMI_LOC_EVENT_GEOFENCE_PROXIMITY_NOTIFICATION_IND_V02,
+    sizeof(qmiLocEventGeofenceProximityIndMsgT_v02),
+    QMI_LOC_EVENT_MASK_GEOFENCE_PROXIMITY_NOTIFICATION_V02},
+
+    //GNSS Measurement Indication
+   { QMI_LOC_EVENT_GNSS_MEASUREMENT_REPORT_IND_V02,
+     sizeof(qmiLocEventGnssSvMeasInfoIndMsgT_v02),
+     QMI_LOC_EVENT_MASK_GNSS_MEASUREMENT_REPORT_V02 },
+
+    //GNSS Measurement Indication
+   { QMI_LOC_EVENT_SV_POLYNOMIAL_REPORT_IND_V02,
+    sizeof(qmiLocEventGnssSvPolyIndMsgT_v02),
+    QMI_LOC_EVENT_MASK_GNSS_SV_POLYNOMIAL_REPORT_V02 },
+
+  // for GDT
+  { QMI_LOC_EVENT_GDT_UPLOAD_BEGIN_STATUS_REQ_IND_V02,
+    sizeof(qmiLocEventGdtUploadBeginStatusReqIndMsgT_v02),
+    QMI_LOC_EVENT_MASK_GDT_UPLOAD_BEGIN_REQ_V02,
+  },
+
+  { QMI_LOC_EVENT_GDT_UPLOAD_END_REQ_IND_V02,
+    sizeof(qmiLocEventGdtUploadEndReqIndMsgT_v02),
+    QMI_LOC_EVENT_MASK_GDT_UPLOAD_END_REQ_V02,
+  },
+
+   //GNSS measurement event
+  { QMI_LOC_EVENT_GNSS_MEASUREMENT_REPORT_IND_V02 ,
+    sizeof(qmiLocEventGnssSvMeasInfoIndMsgT_v02),
+    QMI_LOC_EVENT_MASK_GNSS_MEASUREMENT_REPORT_V02},
+
+  { QMI_LOC_EVENT_DBT_POSITION_REPORT_IND_V02,
+    sizeof(qmiLocEventDbtPositionReportIndMsgT_v02),
+    0},
+
+  { QMI_LOC_EVENT_GEOFENCE_BATCHED_DWELL_NOTIFICATION_IND_V02,
+    sizeof(qmiLocEventGeofenceBatchedDwellIndMsgT_v02),
+    QMI_LOC_EVENT_MASK_GEOFENCE_BATCH_DWELL_NOTIFICATION_V02},
+
+  { QMI_LOC_EVENT_GET_TIME_ZONE_INFO_IND_V02,
+    sizeof(qmiLocEventGetTimeZoneReqIndMsgT_v02),
+    QMI_LOC_EVENT_MASK_GET_TIME_ZONE_REQ_V02},
+
+  // Batching Status event
+  { QMI_LOC_EVENT_BATCHING_STATUS_IND_V02,
+    sizeof(qmiLocEventBatchingStatusIndMsgT_v02),
+    QMI_LOC_EVENT_MASK_BATCHING_STATUS_V02},
+
+  // TDP download
+  { QMI_LOC_EVENT_GDT_DOWNLOAD_BEGIN_REQ_IND_V02,
+    sizeof(qmiLocEventGdtDownloadBeginReqIndMsgT_v02),
+    0},
+
+  { QMI_LOC_EVENT_GDT_RECEIVE_DONE_IND_V02,
+    sizeof(qmiLocEventGdtReceiveDoneIndMsgT_v02),
+    0},
+
+  { QMI_LOC_EVENT_GDT_DOWNLOAD_END_REQ_IND_V02,
+    sizeof(qmiLocEventGdtDownloadEndReqIndMsgT_v02),
+    0}
+};
+
+/* table to relate the respInd Id with its size */
+typedef struct
+{
+  uint32_t respIndId;
+  size_t   respIndSize;
+}locClientRespIndTableStructT;
+
+static const locClientRespIndTableStructT locClientRespIndTable[]= {
+
+  // get service revision ind
+  { QMI_LOC_GET_SERVICE_REVISION_IND_V02,
+    sizeof(qmiLocGetServiceRevisionIndMsgT_v02)},
+
+  // Get Fix Criteria Resp Ind
+  { QMI_LOC_GET_FIX_CRITERIA_IND_V02,
+     sizeof(qmiLocGetFixCriteriaIndMsgT_v02)},
+
+  // NI User Resp In
+  { QMI_LOC_NI_USER_RESPONSE_IND_V02,
+    sizeof(qmiLocNiUserRespIndMsgT_v02)},
+
+  //Inject Predicted Orbits Data Resp Ind
+  { QMI_LOC_INJECT_PREDICTED_ORBITS_DATA_IND_V02,
+    sizeof(qmiLocInjectPredictedOrbitsDataIndMsgT_v02)},
+
+  //Get Predicted Orbits Data Src Resp Ind
+  { QMI_LOC_GET_PREDICTED_ORBITS_DATA_SOURCE_IND_V02,
+    sizeof(qmiLocGetPredictedOrbitsDataSourceIndMsgT_v02)},
+
+  // Get Predicted Orbits Data Validity Resp Ind
+   { QMI_LOC_GET_PREDICTED_ORBITS_DATA_VALIDITY_IND_V02,
+     sizeof(qmiLocGetPredictedOrbitsDataValidityIndMsgT_v02)},
+
+   // Inject UTC Time Resp Ind
+   { QMI_LOC_INJECT_UTC_TIME_IND_V02,
+     sizeof(qmiLocInjectUtcTimeIndMsgT_v02)},
+
+   //Inject Position Resp Ind
+   { QMI_LOC_INJECT_POSITION_IND_V02,
+     sizeof(qmiLocInjectPositionIndMsgT_v02)},
+
+   //Set Engine Lock Resp Ind
+   { QMI_LOC_SET_ENGINE_LOCK_IND_V02,
+     sizeof(qmiLocSetEngineLockIndMsgT_v02)},
+
+   //Get Engine Lock Resp Ind
+   { QMI_LOC_GET_ENGINE_LOCK_IND_V02,
+     sizeof(qmiLocGetEngineLockIndMsgT_v02)},
+
+   //Set SBAS Config Resp Ind
+   { QMI_LOC_SET_SBAS_CONFIG_IND_V02,
+     sizeof(qmiLocSetSbasConfigIndMsgT_v02)},
+
+   //Get SBAS Config Resp Ind
+   { QMI_LOC_GET_SBAS_CONFIG_IND_V02,
+     sizeof(qmiLocGetSbasConfigIndMsgT_v02)},
+
+   //Set NMEA Types Resp Ind
+   { QMI_LOC_SET_NMEA_TYPES_IND_V02,
+     sizeof(qmiLocSetNmeaTypesIndMsgT_v02)},
+
+   //Get NMEA Types Resp Ind
+   { QMI_LOC_GET_NMEA_TYPES_IND_V02,
+     sizeof(qmiLocGetNmeaTypesIndMsgT_v02)},
+
+   //Set Low Power Mode Resp Ind
+   { QMI_LOC_SET_LOW_POWER_MODE_IND_V02,
+     sizeof(qmiLocSetLowPowerModeIndMsgT_v02)},
+
+   //Get Low Power Mode Resp Ind
+   { QMI_LOC_GET_LOW_POWER_MODE_IND_V02,
+     sizeof(qmiLocGetLowPowerModeIndMsgT_v02)},
+
+   //Set Server Resp Ind
+   { QMI_LOC_SET_SERVER_IND_V02,
+     sizeof(qmiLocSetServerIndMsgT_v02)},
+
+   //Get Server Resp Ind
+   { QMI_LOC_GET_SERVER_IND_V02,
+     sizeof(qmiLocGetServerIndMsgT_v02)},
+
+    //Delete Assist Data Resp Ind
+   { QMI_LOC_DELETE_ASSIST_DATA_IND_V02,
+     sizeof(qmiLocDeleteAssistDataIndMsgT_v02)},
+
+   //Set AP cache injection Resp Ind
+   { QMI_LOC_INJECT_APCACHE_DATA_IND_V02,
+     sizeof(qmiLocInjectApCacheDataIndMsgT_v02)},
+
+   //Set No AP cache injection Resp Ind
+   { QMI_LOC_INJECT_APDONOTCACHE_DATA_IND_V02,
+     sizeof(qmiLocInjectApDoNotCacheDataIndMsgT_v02)},
+
+   //Set XTRA-T Session Control Resp Ind
+   { QMI_LOC_SET_XTRA_T_SESSION_CONTROL_IND_V02,
+     sizeof(qmiLocSetXtraTSessionControlIndMsgT_v02)},
+
+   //Get XTRA-T Session Control Resp Ind
+   { QMI_LOC_GET_XTRA_T_SESSION_CONTROL_IND_V02,
+     sizeof(qmiLocGetXtraTSessionControlIndMsgT_v02)},
+
+   //Inject Wifi Position Resp Ind
+   { QMI_LOC_INJECT_WIFI_POSITION_IND_V02,
+     sizeof(qmiLocInjectWifiPositionIndMsgT_v02)},
+
+   //Notify Wifi Status Resp Ind
+   { QMI_LOC_NOTIFY_WIFI_STATUS_IND_V02,
+     sizeof(qmiLocNotifyWifiStatusIndMsgT_v02)},
+
+   //Get Registered Events Resp Ind
+   { QMI_LOC_GET_REGISTERED_EVENTS_IND_V02,
+     sizeof(qmiLocGetRegisteredEventsIndMsgT_v02)},
+
+   //Set Operation Mode Resp Ind
+   { QMI_LOC_SET_OPERATION_MODE_IND_V02,
+     sizeof(qmiLocSetOperationModeIndMsgT_v02)},
+
+   //Get Operation Mode Resp Ind
+   { QMI_LOC_GET_OPERATION_MODE_IND_V02,
+     sizeof(qmiLocGetOperationModeIndMsgT_v02)},
+
+   //Set SPI Status Resp Ind
+   { QMI_LOC_SET_SPI_STATUS_IND_V02,
+     sizeof(qmiLocSetSpiStatusIndMsgT_v02)},
+
+   //Inject Sensor Data Resp Ind
+   { QMI_LOC_INJECT_SENSOR_DATA_IND_V02,
+     sizeof(qmiLocInjectSensorDataIndMsgT_v02)},
+
+   //Inject Time Sync Data Resp Ind
+   { QMI_LOC_INJECT_TIME_SYNC_DATA_IND_V02,
+     sizeof(qmiLocInjectTimeSyncDataIndMsgT_v02)},
+
+   //Set Cradle Mount config Resp Ind
+   { QMI_LOC_SET_CRADLE_MOUNT_CONFIG_IND_V02,
+     sizeof(qmiLocSetCradleMountConfigIndMsgT_v02)},
+
+   //Get Cradle Mount config Resp Ind
+   { QMI_LOC_GET_CRADLE_MOUNT_CONFIG_IND_V02,
+     sizeof(qmiLocGetCradleMountConfigIndMsgT_v02)},
+
+   //Set External Power config Resp Ind
+   { QMI_LOC_SET_EXTERNAL_POWER_CONFIG_IND_V02,
+     sizeof(qmiLocSetExternalPowerConfigIndMsgT_v02)},
+
+   //Get External Power config Resp Ind
+   { QMI_LOC_GET_EXTERNAL_POWER_CONFIG_IND_V02,
+     sizeof(qmiLocGetExternalPowerConfigIndMsgT_v02)},
+
+   //Location server connection status
+   { QMI_LOC_INFORM_LOCATION_SERVER_CONN_STATUS_IND_V02,
+     sizeof(qmiLocInformLocationServerConnStatusIndMsgT_v02)},
+
+   //Set Protocol Config Parameters
+   { QMI_LOC_SET_PROTOCOL_CONFIG_PARAMETERS_IND_V02,
+     sizeof(qmiLocSetProtocolConfigParametersIndMsgT_v02)},
+
+   //Get Protocol Config Parameters
+   { QMI_LOC_GET_PROTOCOL_CONFIG_PARAMETERS_IND_V02,
+     sizeof(qmiLocGetProtocolConfigParametersIndMsgT_v02)},
+
+   //Set Sensor Control Config
+   { QMI_LOC_SET_SENSOR_CONTROL_CONFIG_IND_V02,
+     sizeof(qmiLocSetSensorControlConfigIndMsgT_v02)},
+
+   //Get Sensor Control Config
+   { QMI_LOC_GET_SENSOR_CONTROL_CONFIG_IND_V02,
+     sizeof(qmiLocGetSensorControlConfigIndMsgT_v02)},
+
+   //Set Sensor Properties
+   { QMI_LOC_SET_SENSOR_PROPERTIES_IND_V02,
+     sizeof(qmiLocSetSensorPropertiesIndMsgT_v02)},
+
+   //Get Sensor Properties
+   { QMI_LOC_GET_SENSOR_PROPERTIES_IND_V02,
+     sizeof(qmiLocGetSensorPropertiesIndMsgT_v02)},
+
+   //Set Sensor Performance Control Config
+   { QMI_LOC_SET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_IND_V02,
+     sizeof(qmiLocSetSensorPerformanceControlConfigIndMsgT_v02)},
+
+   //Get Sensor Performance Control Config
+   { QMI_LOC_GET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_IND_V02,
+     sizeof(qmiLocGetSensorPerformanceControlConfigIndMsgT_v02)},
+   //Inject SUPL certificate
+   { QMI_LOC_INJECT_SUPL_CERTIFICATE_IND_V02,
+     sizeof(qmiLocInjectSuplCertificateIndMsgT_v02) },
+
+   //Delete SUPL certificate
+   { QMI_LOC_DELETE_SUPL_CERTIFICATE_IND_V02,
+     sizeof(qmiLocDeleteSuplCertificateIndMsgT_v02) },
+
+   // Set Position Engine Config
+   { QMI_LOC_SET_POSITION_ENGINE_CONFIG_PARAMETERS_IND_V02,
+     sizeof(qmiLocSetPositionEngineConfigParametersIndMsgT_v02)},
+
+   // Get Position Engine Config
+   { QMI_LOC_GET_POSITION_ENGINE_CONFIG_PARAMETERS_IND_V02,
+     sizeof(qmiLocGetPositionEngineConfigParametersIndMsgT_v02)},
+
+   //Add a Circular Geofence
+   { QMI_LOC_ADD_CIRCULAR_GEOFENCE_IND_V02,
+     sizeof(qmiLocAddCircularGeofenceIndMsgT_v02)},
+
+   //Delete a Geofence
+   { QMI_LOC_DELETE_GEOFENCE_IND_V02,
+     sizeof(qmiLocDeleteGeofenceIndMsgT_v02)} ,
+
+   //Query a Geofence
+   { QMI_LOC_QUERY_GEOFENCE_IND_V02,
+     sizeof(qmiLocQueryGeofenceIndMsgT_v02)},
+
+   //Edit a Geofence
+   { QMI_LOC_EDIT_GEOFENCE_IND_V02,
+     sizeof(qmiLocEditGeofenceIndMsgT_v02)},
+
+   //Get best available position
+   { QMI_LOC_GET_BEST_AVAILABLE_POSITION_IND_V02,
+     sizeof(qmiLocGetBestAvailablePositionIndMsgT_v02)},
+
+   //Secure Get available position
+   { QMI_LOC_SECURE_GET_AVAILABLE_POSITION_IND_V02,
+     sizeof(qmiLocSecureGetAvailablePositionIndMsgT_v02)},
+
+   //Inject motion data
+   { QMI_LOC_INJECT_MOTION_DATA_IND_V02,
+     sizeof(qmiLocInjectMotionDataIndMsgT_v02)},
+
+   //Get NI Geofence list
+   { QMI_LOC_GET_NI_GEOFENCE_ID_LIST_IND_V02,
+     sizeof(qmiLocGetNiGeofenceIdListIndMsgT_v02)},
+
+   //Inject GSM Cell Info
+   { QMI_LOC_INJECT_GSM_CELL_INFO_IND_V02,
+     sizeof(qmiLocInjectGSMCellInfoIndMsgT_v02)},
+
+   //Inject Network Initiated Message
+   { QMI_LOC_INJECT_NETWORK_INITIATED_MESSAGE_IND_V02,
+     sizeof(qmiLocInjectNetworkInitiatedMessageIndMsgT_v02)},
+
+   //WWAN Out of Service Notification
+   { QMI_LOC_WWAN_OUT_OF_SERVICE_NOTIFICATION_IND_V02,
+     sizeof(qmiLocWWANOutOfServiceNotificationIndMsgT_v02)},
+
+   //Pedomete Report
+   { QMI_LOC_PEDOMETER_REPORT_IND_V02,
+     sizeof(qmiLocPedometerReportIndMsgT_v02)},
+
+   { QMI_LOC_INJECT_WCDMA_CELL_INFO_IND_V02,
+     sizeof(qmiLocInjectWCDMACellInfoIndMsgT_v02)},
+
+   { QMI_LOC_INJECT_TDSCDMA_CELL_INFO_IND_V02,
+     sizeof(qmiLocInjectTDSCDMACellInfoIndMsgT_v02)},
+
+   { QMI_LOC_INJECT_SUBSCRIBER_ID_IND_V02,
+     sizeof(qmiLocInjectSubscriberIDIndMsgT_v02)},
+
+   //Inject Wifi AP data Resp Ind
+   { QMI_LOC_INJECT_WIFI_AP_DATA_IND_V02,
+     sizeof(qmiLocInjectWifiApDataIndMsgT_v02)},
+
+   { QMI_LOC_START_BATCHING_IND_V02,
+     sizeof(qmiLocStartBatchingIndMsgT_v02)},
+
+   { QMI_LOC_STOP_BATCHING_IND_V02,
+     sizeof(qmiLocStopBatchingIndMsgT_v02)},
+
+   { QMI_LOC_GET_BATCH_SIZE_IND_V02,
+     sizeof(qmiLocGetBatchSizeIndMsgT_v02)},
+
+   { QMI_LOC_EVENT_LIVE_BATCHED_POSITION_REPORT_IND_V02,
+     sizeof(qmiLocEventPositionReportIndMsgT_v02)},
+
+   { QMI_LOC_EVENT_BATCH_FULL_NOTIFICATION_IND_V02,
+     sizeof(qmiLocEventBatchFullIndMsgT_v02)},
+
+   { QMI_LOC_READ_FROM_BATCH_IND_V02,
+     sizeof(qmiLocReadFromBatchIndMsgT_v02)},
+
+   { QMI_LOC_RELEASE_BATCH_IND_V02,
+     sizeof(qmiLocReleaseBatchIndMsgT_v02)},
+
+   { QMI_LOC_SET_XTRA_VERSION_CHECK_IND_V02,
+     sizeof(qmiLocSetXtraVersionCheckIndMsgT_v02)},
+
+    //Vehicle Sensor Data
+    { QMI_LOC_INJECT_VEHICLE_SENSOR_DATA_IND_V02,
+      sizeof(qmiLocInjectVehicleSensorDataIndMsgT_v02)},
+
+   { QMI_LOC_NOTIFY_WIFI_ATTACHMENT_STATUS_IND_V02,
+     sizeof(qmiLocNotifyWifiAttachmentStatusIndMsgT_v02)},
+
+   { QMI_LOC_NOTIFY_WIFI_ENABLED_STATUS_IND_V02,
+     sizeof(qmiLocNotifyWifiEnabledStatusIndMsgT_v02)},
+
+   { QMI_LOC_SET_PREMIUM_SERVICES_CONFIG_IND_V02,
+     sizeof(qmiLocSetPremiumServicesCfgReqMsgT_v02)},
+
+   { QMI_LOC_GET_AVAILABLE_WWAN_POSITION_IND_V02,
+     sizeof(qmiLocGetAvailWwanPositionIndMsgT_v02)},
+
+   // for TDP
+   { QMI_LOC_INJECT_GTP_CLIENT_DOWNLOADED_DATA_IND_V02,
+     sizeof(qmiLocInjectGtpClientDownloadedDataIndMsgT_v02) },
+
+   // for GDT
+   { QMI_LOC_GDT_UPLOAD_BEGIN_STATUS_IND_V02,
+     sizeof(qmiLocGdtUploadBeginStatusIndMsgT_v02) },
+
+   { QMI_LOC_GDT_UPLOAD_END_IND_V02,
+     sizeof(qmiLocGdtUploadEndIndMsgT_v02) },
+
+   { QMI_LOC_SET_GNSS_CONSTELL_REPORT_CONFIG_IND_V02,
+     sizeof(qmiLocSetGNSSConstRepConfigIndMsgT_v02)},
+
+   { QMI_LOC_START_DBT_IND_V02,
+     sizeof(qmiLocStartDbtIndMsgT_v02)},
+
+   { QMI_LOC_STOP_DBT_IND_V02,
+     sizeof(qmiLocStopDbtIndMsgT_v02)},
+
+   { QMI_LOC_INJECT_TIME_ZONE_INFO_IND_V02,
+     sizeof(qmiLocInjectTimeZoneInfoIndMsgT_v02)},
+
+   { QMI_LOC_QUERY_AON_CONFIG_IND_V02,
+     sizeof(qmiLocQueryAonConfigIndMsgT_v02)},
+
+    // for GTP
+   { QMI_LOC_GTP_AP_STATUS_IND_V02,
+     sizeof(qmiLocGtpApStatusIndMsgT_v02) },
+
+    // for GDT
+   { QMI_LOC_GDT_DOWNLOAD_BEGIN_STATUS_IND_V02,
+     sizeof(qmiLocGdtDownloadBeginStatusIndMsgT_v02) },
+
+   { QMI_LOC_GDT_DOWNLOAD_READY_STATUS_IND_V02,
+    sizeof(qmiLocGdtDownloadReadyStatusIndMsgT_v02) },
+
+   { QMI_LOC_GDT_RECEIVE_DONE_STATUS_IND_V02,
+    sizeof(qmiLocGdtReceiveDoneStatusIndMsgT_v02) },
+
+   { QMI_LOC_GDT_DOWNLOAD_END_STATUS_IND_V02,
+     sizeof(qmiLocGdtDownloadEndStatusIndMsgT_v02) },
+
+   { QMI_LOC_GET_SUPPORTED_FEATURE_IND_V02,
+     sizeof(qmiLocGetSupportedFeatureIndMsgT_v02) },
+
+   //Delete Gnss Service Data Resp Ind
+   { QMI_LOC_DELETE_GNSS_SERVICE_DATA_IND_V02,
+     sizeof(qmiLocDeleteGNSSServiceDataIndMsgT_v02) },
+
+   // for XTRA Client 2.0
+   { QMI_LOC_INJECT_XTRA_DATA_IND_V02,
+     sizeof(qmiLocInjectXtraDataIndMsgT_v02) },
+
+   { QMI_LOC_INJECT_XTRA_PCID_IND_V02,
+     sizeof(qmiLocInjectXtraPcidIndMsgT_v02) }
+};
+
+
+/** whether indication is an event or a response */
+typedef enum { eventIndType =0, respIndType = 1 } locClientIndEnumT;
+
+
+/** @struct locClientInternalState
+ */
+
+typedef struct locClientCbDataStructT locClientCallbackDataType;
+
+struct locClientCbDataStructT
+{
+ // client cookie
+  void *pClientCookie;
+  //QCCI handle for this control point
+  qmi_client_type userHandle;
+
+  // callbacks registered by the clients
+  locClientEventIndCbType eventCallback;
+  locClientRespIndCbType respCallback;
+  locClientErrorCbType   errorCallback;
+
+  // the event mask the client has registered for
+  locClientEventMaskType eventRegMask;
+
+  //pointer to itself for checking consistency data
+   locClientCallbackDataType *pMe;
+};
+
+
+/*===========================================================================
+ *
+ *                          FUNCTION DECLARATION
+ *
+ *==========================================================================*/
+
+/** locClientGetSizeAndTypeByIndId
+ *  @brief this function gets the size and the type (event,
+ *         response)of the indication structure from its ID
+ *  @param [in]  indId  ID of the indication
+ *  @param [out] type   event or response indication
+ *  @param [out] size   size of the indications
+ *
+ *  @return true if the ID was found, false otherwise */
+
+static bool locClientGetSizeAndTypeByIndId (uint32_t indId, size_t *pIndSize,
+                                         locClientIndEnumT *pIndType)
+{
+  // look in the event table
+  if(true == locClientGetSizeByEventIndId(indId, pIndSize))
+  {
+    *pIndType = eventIndType;
+
+    LOC_LOGV("%s:%d]: indId %d is an event size = %d\n", __func__, __LINE__,
+                  indId, (uint32_t)*pIndSize);
+    return true;
+  }
+
+  //else look in response table
+  if(true == locClientGetSizeByRespIndId(indId, pIndSize))
+  {
+    *pIndType = respIndType;
+
+    LOC_LOGV("%s:%d]: indId %d is a resp size = %d\n", __func__, __LINE__,
+                  indId, (uint32_t)*pIndSize);
+    return true;
+  }
+
+  // Id not found
+  LOC_LOGW("%s:%d]: indId %d not found\n", __func__, __LINE__, indId);
+  return false;
+}
+
+/** checkQmiMsgsSupported
+ @brief check the qmi service is supported or not.
+ @param [in] pResponse  pointer to the response received from
+        QMI_LOC service.
+*/
+static void checkQmiMsgsSupported(
+  const uint32_t*          reqIdArray,
+  int                      reqIdArrayLength,
+  qmiLocGetSupportMsgT_v02 *pResponse,
+  uint64_t*                supportedMsg)
+{
+    uint64_t result = 0;
+    if (pResponse->resp.supported_msgs_valid) {
+
+        /* For example, if a service supports exactly four messages with
+        IDs 0, 1, 30, and 31 (decimal), the array (in hexadecimal) is
+        4 bytes [03 00 00 c0]. */
+
+        size_t idx = 0;
+        uint32_t reqId = 0;
+        uint32_t length = 0;
+        uint32_t supportedMsgsLen = pResponse->resp.supported_msgs_len;
+
+        // every bit saves a checked message result
+        uint32_t maxCheckedMsgsSavedNum = sizeof(result)<<3;
+
+        uint32_t loopSize = reqIdArrayLength;
+        loopSize =
+            loopSize < supportedMsgsLen ? loopSize : supportedMsgsLen;
+        loopSize =
+            loopSize < maxCheckedMsgsSavedNum ? loopSize : maxCheckedMsgsSavedNum;
+
+        for (idx = 0; idx < loopSize; idx++) {
+            reqId = reqIdArray[idx];
+            length = reqId >> 3;
+            if(supportedMsgsLen > length) {
+                uint32_t bit = reqId & ((uint32_t)7);
+                if (pResponse->resp.supported_msgs[length] & (1<<bit)) {
+                    result |= ( 1 << idx ) ;
+                }
+            }
+        }
+    } else {
+        LOC_LOGE("%s:%d] Invalid supported message list.\n", __func__, __LINE__);
+    }
+    *supportedMsg = result;
+}
+
+/** convertQmiResponseToLocStatus
+ @brief converts a qmiLocGenRespMsgT to locClientStatusEnumType*
+ @param [in] pResponse; pointer to the response received from
+        QMI_LOC service.
+ @return locClientStatusEnumType corresponding to the
+         response.
+*/
+
+static locClientStatusEnumType convertQmiResponseToLocStatus(
+  qmiLocGenRespMsgT_v02 *pResponse)
+{
+  locClientStatusEnumType status =  eLOC_CLIENT_FAILURE_INTERNAL;
+
+  // if result == SUCCESS don't look at error code
+  if(pResponse->resp.result == QMI_RESULT_SUCCESS_V01 )
+  {
+    status  = eLOC_CLIENT_SUCCESS;
+  }
+  else
+  {
+    switch(pResponse->resp.error)
+    {
+      case QMI_ERR_MALFORMED_MSG_V01:
+      case QMI_ERR_INVALID_ARG_V01:
+        status = eLOC_CLIENT_FAILURE_INVALID_PARAMETER;
+        break;
+
+      case QMI_ERR_DEVICE_IN_USE_V01:
+        status = eLOC_CLIENT_FAILURE_ENGINE_BUSY;
+        break;
+
+      case QMI_ERR_NOT_SUPPORTED_V01:
+        status = eLOC_CLIENT_FAILURE_UNSUPPORTED;
+        break;
+
+      default:
+        status = eLOC_CLIENT_FAILURE_INTERNAL;
+        break;
+    }
+  }
+  LOC_LOGV("%s:%d]: result = %d, error = %d, status = %d\n",
+                __func__, __LINE__, pResponse->resp.result,
+                pResponse->resp.error, status);
+  return status;
+}
+
+/** convertQmiErrorToLocError
+ @brief converts a qmi service error type to
+        locClientErrorEnumType
+ @param [in] error received QMI service.
+ @return locClientErrorEnumType corresponding to the error.
+*/
+
+static locClientErrorEnumType convertQmiErrorToLocError(
+  qmi_client_error_type error)
+{
+  locClientErrorEnumType locError ;
+  switch(error)
+  {
+    case QMI_SERVICE_ERR:
+      locError = eLOC_CLIENT_ERROR_SERVICE_UNAVAILABLE;
+      break;
+
+    default:
+      locError = eLOC_CLIENT_ERROR_SERVICE_UNAVAILABLE;
+      break;
+  }
+  LOC_LOGV("%s:%d]: qmi error = %d, loc error = %d\n",
+                __func__, __LINE__, error, locError);
+  return locError;
+}
+
+/** locClientErrorCb
+ *  @brief handles the QCCI error events, this is called by the
+ *         QCCI infrastructure when the service is no longer
+ *         available.
+ *  @param [in] user handle
+ *  @param [in] error
+ *  @param [in] *err_cb_data
+ */
+
+static void locClientErrorCb
+(
+  qmi_client_type user_handle,
+  qmi_client_error_type error,
+  void *err_cb_data
+)
+{
+  locClientCallbackDataType* pCallbackData =
+        (locClientCallbackDataType *)err_cb_data;
+  locClientErrorCbType localErrorCallback = NULL;
+
+  /* copy the errorCallback function pointer from the callback
+   * data to local variable. This is to protect against the race
+   * condition between open/close and error callback.
+   */
+  if(NULL != pCallbackData)
+  {
+    localErrorCallback = pCallbackData->errorCallback;
+  }
+
+  LOC_LOGD("%s:%d]: Service Error %d received, pCallbackData = %p\n",
+      __func__, __LINE__, error, err_cb_data);
+
+  /* call the error callback
+   * To avoid calling the errorCallback after locClientClose
+   * is called, check pCallbackData->errorCallback again here
+   */
+
+  if( (NULL != pCallbackData) &&
+      (NULL != localErrorCallback) &&
+      (NULL != pCallbackData->errorCallback) &&
+      (pCallbackData == pCallbackData->pMe)  )
+  {
+    //invoke the error callback for the corresponding client
+    localErrorCallback(
+        (locClientHandleType)pCallbackData,
+        convertQmiErrorToLocError(error),
+        pCallbackData->pClientCookie);
+  }
+}
+
+
+/** locClientIndCb
+ *  @brief handles the indications sent from the service, if a
+ *         response indication was received then the it is sent
+ *         to the response callback. If a event indication was
+ *         received then it is sent to the event callback
+ *  @param [in] user handle
+ *  @param [in] msg_id
+ *  @param [in] ind_buf
+ *  @param [in] ind_buf_len
+ *  @param [in] ind_cb_data */
+
+static void locClientIndCb
+(
+ qmi_client_type                user_handle,
+ unsigned int                   msg_id,
+ void                           *ind_buf,
+ unsigned int                   ind_buf_len,
+ void                           *ind_cb_data
+)
+{
+  locClientIndEnumT indType;
+  size_t indSize = 0;
+  qmi_client_error_type rc ;
+  locClientCallbackDataType* pCallbackData =
+      (locClientCallbackDataType *)ind_cb_data;
+
+  LOC_LOGV("%s:%d]: Indication: msg_id=%d buf_len=%d pCallbackData = %p\n",
+                __func__, __LINE__, (uint32_t)msg_id, ind_buf_len,
+                pCallbackData);
+
+  // check callback data
+  if(NULL == pCallbackData ||(pCallbackData != pCallbackData->pMe))
+  {
+    LOC_LOGE("%s:%d]: invalid callback data", __func__, __LINE__);
+    return;
+  }
+
+  // check user handle
+  if(memcmp(&pCallbackData->userHandle, &user_handle, sizeof(user_handle)))
+  {
+    LOC_LOGE("%s:%d]: invalid user_handle got %p expected %p\n",
+        __func__, __LINE__,
+        user_handle, pCallbackData->userHandle);
+    return;
+  }
+  // Get the indication size and type ( eventInd or respInd)
+  if( true == locClientGetSizeAndTypeByIndId(msg_id, &indSize, &indType))
+  {
+    void *indBuffer = NULL;
+
+    // decode the indication
+    indBuffer = malloc(indSize);
+
+    if(NULL == indBuffer)
+    {
+      LOC_LOGE("%s:%d]: memory allocation failed\n", __func__, __LINE__);
+      return;
+    }
+
+    rc = QMI_NO_ERR;
+
+    if (ind_buf_len > 0)
+    {
+        // decode the indication
+        rc = qmi_client_message_decode(
+            user_handle,
+            QMI_IDL_INDICATION,
+            msg_id,
+            ind_buf,
+            ind_buf_len,
+            indBuffer,
+            indSize);
+    }
+
+    if( rc == QMI_NO_ERR )
+    {
+      if(eventIndType == indType)
+      {
+        locClientEventIndUnionType eventIndUnion;
+
+        /* copy the eventCallback function pointer from the callback
+         * data to local variable. This is to protect against the race
+         * condition between open/close and indication callback.
+         */
+        locClientEventIndCbType localEventCallback =
+            pCallbackData->eventCallback;
+
+        // dummy event
+        eventIndUnion.pPositionReportEvent =
+            (qmiLocEventPositionReportIndMsgT_v02 *)indBuffer;
+
+        /* call the event callback
+         * To avoid calling the eventCallback after locClientClose
+         * is called, check pCallbackData->eventCallback again here
+         */
+        if((NULL != localEventCallback) &&
+           (NULL != pCallbackData->eventCallback))
+        {
+          localEventCallback(
+              (locClientHandleType)pCallbackData,
+              msg_id,
+              eventIndUnion,
+              pCallbackData->pClientCookie);
+        }
+      }
+      else if(respIndType == indType)
+      {
+        locClientRespIndUnionType respIndUnion;
+
+        /* copy the respCallback function pointer from the callback
+         * data to local variable. This is to protect against the race
+         * condition between open/close and indication callback.
+         */
+        locClientRespIndCbType localRespCallback =
+            pCallbackData->respCallback;
+
+        // dummy to suppress compiler warnings
+        respIndUnion.pDeleteAssistDataInd =
+            (qmiLocDeleteAssistDataIndMsgT_v02 *)indBuffer;
+
+        /* call the response callback
+         * To avoid calling the respCallback after locClientClose
+         * is called, check pCallbackData->respCallback again here
+         */
+        if((NULL != localRespCallback) &&
+           (NULL != pCallbackData->respCallback))
+        {
+          localRespCallback(
+              (locClientHandleType)pCallbackData,
+              msg_id,
+              respIndUnion,
+              indSize,
+              pCallbackData->pClientCookie);
+        }
+      }
+    }
+    else
+    {
+      LOC_LOGE("%s:%d]: Error decoding indication %d\n",
+                    __func__, __LINE__, rc);
+    }
+    if(indBuffer)
+    {
+      free (indBuffer);
+    }
+  }
+  else // Id not found
+  {
+    LOC_LOGE("%s:%d]: Error indication not found %d\n",
+                  __func__, __LINE__,(uint32_t)msg_id);
+  }
+  return;
+}
+
+
+/** locClientRegisterEventMask
+ *  @brief registers the event mask with loc service
+ *  @param [in] clientHandle
+ *  @param [in] eventRegMask
+ *  @return true if indication was validated; else false */
+
+bool locClientRegisterEventMask(
+    locClientHandleType clientHandle,
+    locClientEventMaskType eventRegMask)
+{
+  locClientStatusEnumType status = eLOC_CLIENT_SUCCESS;
+  locClientReqUnionType reqUnion;
+  qmiLocRegEventsReqMsgT_v02 regEventsReq;
+
+  memset(&regEventsReq, 0, sizeof(regEventsReq));
+
+  regEventsReq.eventRegMask = eventRegMask;
+  reqUnion.pRegEventsReq = &regEventsReq;
+
+  status = locClientSendReq(clientHandle,
+                            QMI_LOC_REG_EVENTS_REQ_V02,
+                            reqUnion);
+
+  if(eLOC_CLIENT_SUCCESS != status )
+  {
+    LOC_LOGE("%s:%d] status %s\n", __func__, __LINE__,
+             loc_get_v02_client_status_name(status) );
+    return false;
+  }
+
+  return true;
+}
+
+/**  validateRequest
+  @brief validates the input request
+  @param [in] reqId       request ID
+  @param [in] reqPayload  Union of pointers to message payload
+  @param [out] ppOutData  Pointer to void *data if successful
+  @param [out] pOutLen    Pointer to length of data if succesful.
+  @return false on failure, true on Success
+*/
+
+static bool validateRequest(
+  uint32_t                    reqId,
+  const locClientReqUnionType reqPayload,
+  void                        **ppOutData,
+  uint32_t                    *pOutLen )
+
+{
+  bool noPayloadFlag = false;
+
+  LOC_LOGV("%s:%d]: reqId = %d\n", __func__, __LINE__, reqId);
+  switch(reqId)
+  {
+    case QMI_LOC_INFORM_CLIENT_REVISION_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocInformClientRevisionReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_REG_EVENTS_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocRegEventsReqMsgT_v02);
+       break;
+    }
+
+    case QMI_LOC_START_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocStartReqMsgT_v02);
+       break;
+    }
+
+    case QMI_LOC_STOP_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocStopReqMsgT_v02);
+       break;
+    }
+
+    case QMI_LOC_NI_USER_RESPONSE_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocNiUserRespReqMsgT_v02);
+       break;
+    }
+
+    case QMI_LOC_INJECT_PREDICTED_ORBITS_DATA_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocInjectPredictedOrbitsDataReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_INJECT_UTC_TIME_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocInjectUtcTimeReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_INJECT_POSITION_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocInjectPositionReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_SET_ENGINE_LOCK_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocSetEngineLockReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_SET_SBAS_CONFIG_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocSetSbasConfigReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_SET_NMEA_TYPES_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocSetNmeaTypesReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_SET_LOW_POWER_MODE_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocSetLowPowerModeReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_SET_SERVER_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocSetServerReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_DELETE_ASSIST_DATA_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocDeleteAssistDataReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_INJECT_APCACHE_DATA_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocInjectApCacheDataReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_INJECT_APDONOTCACHE_DATA_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocInjectApDoNotCacheDataReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_SET_XTRA_T_SESSION_CONTROL_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocSetXtraTSessionControlReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_INJECT_WIFI_POSITION_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocInjectWifiPositionReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_NOTIFY_WIFI_STATUS_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocNotifyWifiStatusReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_SET_OPERATION_MODE_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocSetOperationModeReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_SET_SPI_STATUS_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocSetSpiStatusReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_INJECT_SENSOR_DATA_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocInjectSensorDataReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_INJECT_TIME_SYNC_DATA_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocInjectTimeSyncDataReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_SET_CRADLE_MOUNT_CONFIG_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocSetCradleMountConfigReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_SET_EXTERNAL_POWER_CONFIG_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocSetExternalPowerConfigReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_INFORM_LOCATION_SERVER_CONN_STATUS_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocInformLocationServerConnStatusReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_SET_PROTOCOL_CONFIG_PARAMETERS_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocSetProtocolConfigParametersReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_GET_PROTOCOL_CONFIG_PARAMETERS_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocGetProtocolConfigParametersReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_SET_SENSOR_CONTROL_CONFIG_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocSetSensorControlConfigReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_GET_SENSOR_PROPERTIES_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocGetSensorPropertiesReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_SET_SENSOR_PROPERTIES_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocSetSensorPropertiesReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_SET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocSetSensorPerformanceControlConfigReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_INJECT_SUPL_CERTIFICATE_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocInjectSuplCertificateReqMsgT_v02);
+      break;
+    }
+    case QMI_LOC_DELETE_SUPL_CERTIFICATE_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocDeleteSuplCertificateReqMsgT_v02);
+      break;
+    }
+    case QMI_LOC_SET_POSITION_ENGINE_CONFIG_PARAMETERS_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocSetPositionEngineConfigParametersReqMsgT_v02);
+      break;
+    }
+    case QMI_LOC_GET_POSITION_ENGINE_CONFIG_PARAMETERS_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocGetPositionEngineConfigParametersReqMsgT_v02);
+      break;
+    }
+    case QMI_LOC_ADD_CIRCULAR_GEOFENCE_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocAddCircularGeofenceReqMsgT_v02);
+      break;
+    }
+    case QMI_LOC_DELETE_GEOFENCE_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocDeleteGeofenceReqMsgT_v02);
+      break;
+    }
+    case QMI_LOC_QUERY_GEOFENCE_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocQueryGeofenceReqMsgT_v02);
+      break;
+    }
+    case QMI_LOC_EDIT_GEOFENCE_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocEditGeofenceReqMsgT_v02);
+      break;
+    }
+    case QMI_LOC_GET_BEST_AVAILABLE_POSITION_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocGetBestAvailablePositionReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_SECURE_GET_AVAILABLE_POSITION_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocSecureGetAvailablePositionReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_INJECT_MOTION_DATA_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocInjectMotionDataReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_GET_NI_GEOFENCE_ID_LIST_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocGetNiGeofenceIdListReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_INJECT_GSM_CELL_INFO_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocInjectGSMCellInfoReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_INJECT_NETWORK_INITIATED_MESSAGE_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocInjectNetworkInitiatedMessageReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_PEDOMETER_REPORT_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocPedometerReportReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_INJECT_WCDMA_CELL_INFO_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocInjectWCDMACellInfoReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_INJECT_TDSCDMA_CELL_INFO_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocInjectTDSCDMACellInfoReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_INJECT_SUBSCRIBER_ID_IND_V02:
+    {
+      *pOutLen = sizeof(qmiLocInjectSubscriberIDReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_INJECT_WIFI_AP_DATA_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocInjectWifiApDataReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_GET_BATCH_SIZE_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocGetBatchSizeReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_START_BATCHING_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocStartBatchingReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_READ_FROM_BATCH_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocReadFromBatchReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_STOP_BATCHING_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocStopBatchingReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_RELEASE_BATCH_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocReleaseBatchReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_SET_XTRA_VERSION_CHECK_REQ_V02:
+    {
+        *pOutLen = sizeof(qmiLocSetXtraVersionCheckReqMsgT_v02);
+        break;
+    }
+
+    case QMI_LOC_INJECT_VEHICLE_SENSOR_DATA_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocInjectVehicleSensorDataReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_NOTIFY_WIFI_ATTACHMENT_STATUS_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocNotifyWifiAttachmentStatusReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_NOTIFY_WIFI_ENABLED_STATUS_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocNotifyWifiEnabledStatusReqMsgT_v02);
+      break;
+    }
+
+    case QMI_LOC_SET_PREMIUM_SERVICES_CONFIG_REQ_V02:
+    {
+        *pOutLen = sizeof(qmiLocSetPremiumServicesCfgReqMsgT_v02);
+        break;
+    }
+
+    case QMI_LOC_GET_AVAILABLE_WWAN_POSITION_REQ_V02:
+    {
+        *pOutLen = sizeof(qmiLocGetAvailWwanPositionReqMsgT_v02);
+        break;
+    }
+
+    case QMI_LOC_INJECT_GTP_CLIENT_DOWNLOADED_DATA_REQ_V02:
+    {
+        *pOutLen = sizeof(qmiLocInjectGtpClientDownloadedDataReqMsgT_v02);
+        break;
+    }
+
+    case QMI_LOC_GDT_UPLOAD_BEGIN_STATUS_REQ_V02:
+    {
+        *pOutLen = sizeof(qmiLocGdtUploadBeginStatusReqMsgT_v02);
+        break;
+    }
+
+    case QMI_LOC_GDT_UPLOAD_END_REQ_V02:
+    {
+        *pOutLen = sizeof(qmiLocGdtUploadEndReqMsgT_v02);
+        break;
+    }
+
+    case QMI_LOC_SET_GNSS_CONSTELL_REPORT_CONFIG_V02:
+    {
+        *pOutLen = sizeof(qmiLocSetGNSSConstRepConfigReqMsgT_v02);
+        break;
+    }
+
+    case QMI_LOC_START_DBT_REQ_V02:
+    {
+        *pOutLen = sizeof(qmiLocStartDbtReqMsgT_v02);
+        break;
+    }
+
+    case QMI_LOC_STOP_DBT_REQ_V02:
+    {
+        *pOutLen = sizeof(qmiLocStopDbtReqMsgT_v02);
+        break;
+    }
+
+    case QMI_LOC_INJECT_TIME_ZONE_INFO_REQ_V02:
+    {
+        *pOutLen = sizeof(qmiLocInjectTimeZoneInfoReqMsgT_v02);
+        break;
+    }
+
+    case QMI_LOC_QUERY_AON_CONFIG_REQ_V02:
+    {
+        *pOutLen = sizeof(qmiLocQueryAonConfigReqMsgT_v02);
+        break;
+    }
+
+    case QMI_LOC_GTP_AP_STATUS_REQ_V02:
+    {
+        *pOutLen = sizeof(qmiLocGtpApStatusReqMsgT_v02);
+        break;
+    }
+
+    case QMI_LOC_GDT_DOWNLOAD_BEGIN_STATUS_REQ_V02:
+    {
+        *pOutLen = sizeof(qmiLocGdtDownloadBeginStatusReqMsgT_v02);
+        break;
+    }
+
+    case QMI_LOC_GDT_DOWNLOAD_READY_STATUS_REQ_V02:
+    {
+        *pOutLen = sizeof(qmiLocGdtDownloadReadyStatusReqMsgT_v02);
+        break;
+    }
+
+    case QMI_LOC_GDT_RECEIVE_DONE_STATUS_REQ_V02:
+    {
+        *pOutLen = sizeof(qmiLocGdtReceiveDoneStatusReqMsgT_v02);
+        break;
+    }
+
+    case QMI_LOC_GDT_DOWNLOAD_END_STATUS_REQ_V02:
+    {
+        *pOutLen = sizeof(qmiLocGdtDownloadEndStatusReqMsgT_v02);
+        break;
+    }
+
+    case QMI_LOC_GET_SUPPORTED_FEATURE_REQ_V02:
+    {
+        *pOutLen = sizeof(qmiLocGetSupportedFeatureReqMsgT_v02);
+        break;
+    }
+
+    case QMI_LOC_DELETE_GNSS_SERVICE_DATA_REQ_V02:
+    {
+      *pOutLen = sizeof(qmiLocDeleteGNSSServiceDataReqMsgT_v02);
+      break;
+    }
+
+    // XTRA Client 2.0
+    case QMI_LOC_INJECT_XTRA_DATA_REQ_V02:
+    {
+        *pOutLen = sizeof(qmiLocInjectXtraDataReqMsgT_v02);
+        break;
+    }
+
+    case QMI_LOC_INJECT_XTRA_PCID_REQ_V02:
+    {
+        *pOutLen = sizeof(qmiLocInjectXtraPcidReqMsgT_v02);
+        break;
+    }
+
+    // ALL requests with no payload
+    case QMI_LOC_GET_SERVICE_REVISION_REQ_V02:
+    case QMI_LOC_GET_FIX_CRITERIA_REQ_V02:
+    case QMI_LOC_GET_PREDICTED_ORBITS_DATA_SOURCE_REQ_V02:
+    case QMI_LOC_GET_PREDICTED_ORBITS_DATA_VALIDITY_REQ_V02:
+    case QMI_LOC_GET_ENGINE_LOCK_REQ_V02:
+    case QMI_LOC_GET_SBAS_CONFIG_REQ_V02:
+    case QMI_LOC_GET_NMEA_TYPES_REQ_V02:
+    case QMI_LOC_GET_LOW_POWER_MODE_REQ_V02:
+    case QMI_LOC_GET_SERVER_REQ_V02:
+    case QMI_LOC_GET_XTRA_T_SESSION_CONTROL_REQ_V02:
+    case QMI_LOC_GET_REGISTERED_EVENTS_REQ_V02:
+    case QMI_LOC_GET_OPERATION_MODE_REQ_V02:
+    case QMI_LOC_GET_CRADLE_MOUNT_CONFIG_REQ_V02:
+    case QMI_LOC_GET_EXTERNAL_POWER_CONFIG_REQ_V02:
+    case QMI_LOC_GET_SENSOR_CONTROL_CONFIG_REQ_V02:
+    case QMI_LOC_GET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_REQ_V02:
+    case QMI_LOC_WWAN_OUT_OF_SERVICE_NOTIFICATION_REQ_V02:
+    case QMI_LOC_GET_SUPPORTED_MSGS_REQ_V02:
+    case QMI_LOC_GET_SUPPORTED_FIELDS_REQ_V02:
+    {
+      noPayloadFlag = true;
+      break;
+    }
+
+    default:
+      LOC_LOGW("%s:%d]: Error unknown reqId=%d\n", __func__, __LINE__,
+                    reqId);
+      return false;
+  }
+  if(true == noPayloadFlag)
+  {
+    *ppOutData = NULL;
+    *pOutLen = 0;
+  }
+  else
+  {
+    //set dummy pointer for request union
+    *ppOutData = (void*) reqPayload.pInformClientRevisionReq;
+  }
+  LOC_LOGV("%s:%d]: reqId=%d, len = %d\n", __func__, __LINE__,
+                reqId, *pOutLen);
+  return true;
+}
+
+/** locClientQmiCtrlPointInit
+ @brief wait for the service to come up or timeout; when the
+        service comes up initialize the control point and set
+        internal handle and indication callback.
+ @param pQmiClient,
+*/
+
+static locClientStatusEnumType locClientQmiCtrlPointInit(
+    locClientCallbackDataType *pLocClientCbData,
+    int instanceId)
+{
+  qmi_client_type clnt, notifier;
+  bool notifierInitFlag = false;
+  locClientStatusEnumType status = eLOC_CLIENT_SUCCESS;
+  // os_params must stay in the same scope as notifier
+  // because when notifier is initialized, the pointer
+  // of os_params is retained in QMI framework, and it
+  // used when notifier is released.
+  qmi_client_os_params os_params;
+  // instances of this service
+  qmi_service_info serviceInfo;
+
+  do
+  {
+    qmi_client_error_type rc = QMI_NO_ERR;
+
+    // Get the service object for the qmiLoc Service
+    qmi_idl_service_object_type locClientServiceObject =
+      loc_get_service_object_v02();
+
+    // Verify that qmiLoc_get_service_object did not return NULL
+    if (NULL == locClientServiceObject)
+    {
+        LOC_LOGE("%s:%d]: qmiLoc_get_service_object_v02 failed\n" ,
+                    __func__, __LINE__ );
+       status = eLOC_CLIENT_FAILURE_INTERNAL;
+       break;
+    }
+
+    // register for service notification
+    rc = qmi_client_notifier_init(locClientServiceObject, &os_params, &notifier);
+    notifierInitFlag = (NULL != notifier);
+
+    if (rc != QMI_NO_ERR) {
+        LOC_LOGE("%s:%d]: qmi_client_notifier_init failed %d\n",
+                 __func__, __LINE__, rc);
+        status = eLOC_CLIENT_FAILURE_INTERNAL;
+        break;
+    }
+
+    while (1) {
+        QMI_CCI_OS_SIGNAL_CLEAR(&os_params);
+
+        if (instanceId >= 0) {
+            // use instance-specific lookup
+            rc = qmi_client_get_service_instance(locClientServiceObject, instanceId, &serviceInfo);
+        } else {
+            // lookup service with any instance id
+            rc = qmi_client_get_any_service(locClientServiceObject, &serviceInfo);
+        }
+
+        // get the service addressing information
+        LOC_LOGV("%s:%d]: qmi_client_get_service() rc: %d ", __func__, __LINE__, rc);
+
+        if(rc == QMI_NO_ERR)
+            break;
+
+        QMI_CCI_OS_SIGNAL_WAIT(&os_params, 0);
+    }
+
+    LOC_LOGV("%s:%d]: passing the pointer %p to qmi_client_init \n",
+                      __func__, __LINE__, pLocClientCbData);
+
+    // initialize the client
+    //sent the address of the first service found
+    // if IPC router is present, this will go to the service instance
+    // enumerated over IPC router, else it will go over the next transport where
+    // the service was enumerated.
+    rc = qmi_client_init(&serviceInfo, locClientServiceObject,
+                         locClientIndCb, (void *) pLocClientCbData,
+                         NULL, &clnt);
+
+    if(rc != QMI_NO_ERR)
+    {
+      LOC_LOGE("%s:%d]: qmi_client_init error %d\n",
+                    __func__, __LINE__, rc);
+
+      status = eLOC_CLIENT_FAILURE_INTERNAL;
+      break;
+    }
+
+    LOC_LOGV("%s:%d]: passing the pointer %p to"
+                  "qmi_client_register_error_cb \n",
+                   __func__, __LINE__, pLocClientCbData);
+
+    // register error callback
+    rc  = qmi_client_register_error_cb(clnt,
+        locClientErrorCb, (void *) pLocClientCbData);
+
+    if( QMI_NO_ERR != rc)
+    {
+      LOC_LOGE("%s:%d]: could not register QCCI error callback error:%d\n",
+                    __func__, __LINE__, rc);
+
+      status = eLOC_CLIENT_FAILURE_INTERNAL;
+      break;
+    }
+
+    // copy the clnt handle returned in qmi_client_init
+    memcpy(&(pLocClientCbData->userHandle), &clnt, sizeof(qmi_client_type));
+
+    status = eLOC_CLIENT_SUCCESS;
+
+  } while(0);
+
+  /* release the notifier handle */
+  if(true == notifierInitFlag)
+  {
+    qmi_client_release(notifier);
+  }
+
+  return status;
+}
+//----------------------- END INTERNAL FUNCTIONS ----------------------------------------
+
+/** locClientOpenInstance
+  @brief Connects a location client to the location engine. If the connection
+         is successful, returns a handle that the location client uses for
+         future location operations.
+
+  @param [in] eventRegMask     Mask of asynchronous events the client is
+                               interested in receiving
+  @param [in] instanceId       Value of QMI service instance id to use.
+  @param [in] eventIndCb       Function to be invoked to handle an event.
+  @param [in] respIndCb        Function to be invoked to handle a response
+                               indication.
+  @param [out] locClientHandle Handle to be used by the client
+                               for any subsequent requests.
+
+  @return
+  One of the following error codes:
+  - eLOC_CLIENT_SUCCESS  -- If the connection is opened.
+  - non-zero error code(see locClientStatusEnumType)--  On failure.
+*/
+locClientStatusEnumType locClientOpenInstance (
+  locClientEventMaskType         eventRegMask,
+  int                            instanceId,
+  const locClientCallbacksType*  pLocClientCallbacks,
+  locClientHandleType*           pLocClientHandle,
+  const void*                    pClientCookie)
+{
+  locClientStatusEnumType status = eLOC_CLIENT_SUCCESS;
+  locClientCallbackDataType *pCallbackData = NULL;
+
+  // check input parameters
+  if( (NULL == pLocClientCallbacks) || (NULL == pLocClientHandle)
+      || (NULL == pLocClientCallbacks->respIndCb) ||
+      (pLocClientCallbacks->size != sizeof(locClientCallbacksType)))
+  {
+    LOC_LOGE("%s:%d]: Invalid parameters in locClientOpen\n",
+             __func__, __LINE__);
+    return eLOC_CLIENT_FAILURE_INVALID_PARAMETER;
+  }
+
+  do
+  {
+    // Allocate memory for the callback data
+    pCallbackData =
+        ( locClientCallbackDataType*)calloc(
+            1, sizeof(locClientCallbackDataType));
+
+    if(NULL == pCallbackData)
+    {
+      LOC_LOGE("%s:%d]: Could not allocate memory for callback data \n",
+                        __func__, __LINE__);
+      status = eLOC_CLIENT_FAILURE_INTERNAL;
+      break;
+    }
+
+    /* Initialize the QMI control point; this function will block
+     * until a service is up or a timeout occurs. If the connection to
+     * the service succeeds the callback data will be filled in with
+     * a qmi_client value.
+     */
+
+
+    EXIT_LOG_CALLFLOW(%s, "loc client open");
+    status = locClientQmiCtrlPointInit(pCallbackData, instanceId);
+
+    LOC_LOGV ("%s:%d] locClientQmiCtrlPointInit returned %d\n",
+                    __func__, __LINE__, status);
+
+    if(status != eLOC_CLIENT_SUCCESS)
+    {
+      free(pCallbackData);
+      pCallbackData = NULL;
+      LOC_LOGE ("%s:%d] locClientQmiCtrlPointInit returned %d\n",
+                    __func__, __LINE__, status);
+      break;
+    }
+     // set the self pointer
+    pCallbackData->pMe = pCallbackData;
+     // set the handle to the callback data
+    *pLocClientHandle = (locClientHandleType)pCallbackData;
+
+    if(true != locClientRegisterEventMask(*pLocClientHandle,eventRegMask))
+    {
+      LOC_LOGE("%s:%d]: Error sending registration mask\n",
+                  __func__, __LINE__);
+
+      // release the client
+      locClientClose(pLocClientHandle);
+
+      status = eLOC_CLIENT_FAILURE_INTERNAL;
+      break;
+    }
+
+    /* Initialize rest of the client structure now that the connection
+     * to the service has been created successfully.
+     */
+
+    //fill in the event callback
+     pCallbackData->eventCallback = pLocClientCallbacks->eventIndCb;
+
+     //fill in the response callback
+     pCallbackData->respCallback = pLocClientCallbacks->respIndCb;
+
+     //fill in the error callback
+     pCallbackData->errorCallback = pLocClientCallbacks->errorCb;
+
+     //set the client event registration mask
+     pCallbackData->eventRegMask = eventRegMask;
+
+     // set the client cookie
+     pCallbackData->pClientCookie = (void *)pClientCookie;
+
+  }while(0);
+
+  if(eLOC_CLIENT_SUCCESS != status)
+  {
+    *pLocClientHandle = LOC_CLIENT_INVALID_HANDLE_VALUE;
+    LOC_LOGE("%s:%d]: Error! status = %d\n", __func__, __LINE__,status);
+  }
+
+  else
+  {
+    LOC_LOGD("%s:%d]: returning handle = %p, user_handle=%p, status = %d\n",
+                __func__, __LINE__, *pLocClientHandle,
+                pCallbackData->userHandle, status);
+  }
+
+  return(status);
+}
+
+/** locClientOpen
+  @brief Connects a location client to the location engine. If the connection
+         is successful, returns a handle that the location client uses for
+         future location operations.
+
+  @param [in] eventRegMask     Mask of asynchronous events the client is
+                               interested in receiving
+  @param [in] eventIndCb       Function to be invoked to handle an event.
+  @param [in] respIndCb        Function to be invoked to handle a response
+                               indication.
+  @param [out] locClientHandle Handle to be used by the client
+                               for any subsequent requests.
+
+  @return
+  One of the following error codes:
+  - eLOC_CLIENT_SUCCESS  -- If the connection is opened.
+  - non-zero error code(see locClientStatusEnumType)--  On failure.
+*/
+
+locClientStatusEnumType locClientOpen (
+  locClientEventMaskType         eventRegMask,
+  const locClientCallbacksType*  pLocClientCallbacks,
+  locClientHandleType*           pLocClientHandle,
+  const void*                    pClientCookie)
+{
+  int instanceId;
+  locClientStatusEnumType status;
+  int tries = 1;
+#ifdef _ANDROID_
+  switch (getTargetGnssType(loc_get_target()))
+  {
+  case GNSS_GSS:
+    instanceId = eLOC_CLIENT_INSTANCE_ID_GSS;
+    break;
+  case GNSS_QCA1530:
+    instanceId = eLOC_CLIENT_INSTANCE_ID_QCA1530;
+    break;
+  case GNSS_MSM:
+    instanceId = eLOC_CLIENT_INSTANCE_ID_MSM;
+    break;
+  case GNSS_MDM:
+    instanceId = eLOC_CLIENT_INSTANCE_ID_MDM;
+    break;
+  case GNSS_AUTO:
+    instanceId = eLOC_CLIENT_INSTANCE_ID_GSS_AUTO;
+    break;
+  default:
+    instanceId = eLOC_CLIENT_INSTANCE_ID_ANY;
+    break;
+  }
+
+  LOC_LOGI("%s:%d]: Service instance id is %d\n",
+             __func__, __LINE__, instanceId);
+#else
+  instanceId = eLOC_CLIENT_INSTANCE_ID_ANY;
+#endif
+
+  while ((status = locClientOpenInstance(eventRegMask, instanceId, pLocClientCallbacks,
+          pLocClientHandle, pClientCookie)) != eLOC_CLIENT_SUCCESS) {
+    if (tries <= LOC_CLIENT_MAX_OPEN_RETRIES) {
+      LOC_LOGE("%s:%d]: failed with status=%d on try %d",
+               __func__, __LINE__, status, tries);
+      tries++;
+      sleep(LOC_CLIENT_TIME_BETWEEN_OPEN_RETRIES);
+    } else {
+      LOC_LOGE("%s:%d]: failed with status=%d Aborting...",
+               __func__, __LINE__, status);
+      break;
+    }
+  }
+
+  return status;
+}
+
+/** locClientClose
+  @brief Disconnects a client from the location engine.
+  @param [in] pLocClientHandle  Pointer to the handle returned by the
+                                locClientOpen() function.
+  @return
+  One of the following error codes:
+  - 0 (eLOC_CLIENT_SUCCESS) - On success.
+  - non-zero error code(see locClientStatusEnumType) - On failure.
+*/
+
+locClientStatusEnumType locClientClose(
+  locClientHandleType* pLocClientHandle)
+{
+  // convert handle to callback data
+  locClientCallbackDataType *pCallbackData;
+  qmi_client_error_type rc = QMI_NO_ERR; //No error
+
+  if(NULL == pLocClientHandle)
+  {
+    // invalid handle
+    LOC_LOGE("%s:%d]: invalid pointer to handle \n",
+                  __func__, __LINE__);
+
+    return(eLOC_CLIENT_FAILURE_INVALID_PARAMETER);
+  }
+
+  pCallbackData = (locClientCallbackDataType *)(*pLocClientHandle);
+
+  // check the input handle for sanity
+  if(NULL == pCallbackData ||
+     NULL == pCallbackData->userHandle ||
+     pCallbackData != pCallbackData->pMe )
+  {
+    // invalid handle
+    LOC_LOGE("%s:%d]: invalid handle \n",
+                  __func__, __LINE__);
+
+    return(eLOC_CLIENT_FAILURE_INVALID_HANDLE);
+  }
+
+  LOC_LOGV("locClientClose releasing handle %p, user handle %p\n",
+      *pLocClientHandle, pCallbackData->userHandle );
+
+  // NEXT call goes out to modem. We log the callflow before it
+  // actually happens to ensure the this comes before resp callflow
+  // back from the modem, to avoid confusing log order. We trust
+  // that the QMI framework is robust.
+  EXIT_LOG_CALLFLOW(%s, "loc client close");
+
+  // release the handle
+  rc = qmi_client_release(pCallbackData->userHandle);
+  if(QMI_NO_ERR != rc )
+  {
+    LOC_LOGW("%s:%d]: qmi_client_release error %d for client %p\n",
+                   __func__, __LINE__, rc, pCallbackData->userHandle);
+    return(eLOC_CLIENT_FAILURE_INTERNAL);
+  }
+
+  /* clear the memory allocated to callback data to minimize the chances
+   *  of a race condition occurring between close and the indication
+   *  callback
+   */
+  memset(pCallbackData, 0, sizeof(*pCallbackData));
+
+  // free the memory assigned in locClientOpen
+  free(pCallbackData);
+  pCallbackData= NULL;
+
+  // set the handle to invalid value
+  *pLocClientHandle = LOC_CLIENT_INVALID_HANDLE_VALUE;
+  return eLOC_CLIENT_SUCCESS;
+}
+
+/** locClientSendReq
+  @brief Sends a message to the location engine. If the locClientSendMsg()
+         function is successful, the client should expect an indication
+         (except start, stop, event reg and sensor injection messages),
+         through the registered callback in the locOpen() function. The
+         indication will contain the status of the request and if status is a
+         success, indication also contains the payload
+         associated with response.
+  @param [in] handle Handle returned by the locClientOpen()
+              function.
+  @param [in] reqId         message ID of the request
+  @param [in] reqPayload   Payload of the request, can be NULL
+                            if request has no payload
+
+  @return
+  One of the following error codes:
+  - 0 (eLOC_CLIENT_SUCCESS ) - On success.
+  - non-zero error code (see locClientStatusEnumType) - On failure.
+*/
+
+locClientStatusEnumType locClientSendReq(
+  locClientHandleType      handle,
+  uint32_t                 reqId,
+  locClientReqUnionType    reqPayload )
+{
+  locClientStatusEnumType status = eLOC_CLIENT_SUCCESS;
+  qmi_client_error_type rc = QMI_NO_ERR; //No error
+  qmiLocGenRespMsgT_v02 resp;
+  uint32_t reqLen = 0;
+  void *pReqData = NULL;
+  locClientCallbackDataType *pCallbackData =
+        (locClientCallbackDataType *)handle;
+
+  // check the input handle for sanity
+   if(NULL == pCallbackData ||
+      NULL == pCallbackData->userHandle ||
+      pCallbackData != pCallbackData->pMe )
+   {
+     // did not find the handle in the client List
+     LOC_LOGE("%s:%d]: invalid handle \n",
+                   __func__, __LINE__);
+
+     return(eLOC_CLIENT_FAILURE_INVALID_HANDLE);
+   }
+
+  // validate that the request is correct
+  if (validateRequest(reqId, reqPayload, &pReqData, &reqLen) == false)
+  {
+
+    LOC_LOGE("%s:%d] error invalid request\n", __func__,
+                __LINE__);
+
+    return(eLOC_CLIENT_FAILURE_INVALID_PARAMETER);
+  }
+
+  LOC_LOGV("%s:%d] sending reqId= %d, len = %d\n", __func__,
+                __LINE__, reqId, reqLen);
+
+  // NEXT call goes out to modem. We log the callflow before it
+  // actually happens to ensure the this comes before resp callflow
+  // back from the modem, to avoid confusing log order. We trust
+  // that the QMI framework is robust.
+  EXIT_LOG_CALLFLOW(%s, loc_get_v02_event_name(reqId));
+  rc = qmi_client_send_msg_sync(
+      pCallbackData->userHandle,
+      reqId,
+      pReqData,
+      reqLen,
+      &resp,
+      sizeof(resp),
+      LOC_CLIENT_ACK_TIMEOUT);
+
+  LOC_LOGV("%s:%d] qmi_client_send_msg_sync returned %d\n", __func__,
+                __LINE__, rc);
+
+  if (QMI_SERVICE_ERR == rc)
+  {
+    LOC_LOGE("%s:%d]: send_msg_sync error: QMI_SERVICE_ERR\n",__func__, __LINE__);
+    return(eLOC_CLIENT_FAILURE_PHONE_OFFLINE);
+  }
+  else if (rc != QMI_NO_ERR)
+  {
+    LOC_LOGE("%s:%d]: send_msg_sync error: %d\n",__func__, __LINE__, rc);
+    return(eLOC_CLIENT_FAILURE_INTERNAL);
+  }
+
+  // map the QCCI response to Loc API v02 status
+  status = convertQmiResponseToLocStatus(&resp);
+
+  // if the request is to change registered events, update the
+  // loc api copy of that
+  if(eLOC_CLIENT_SUCCESS == status &&
+      QMI_LOC_REG_EVENTS_REQ_V02 == reqId)
+  {
+    if(NULL != reqPayload.pRegEventsReq )
+    {
+      pCallbackData->eventRegMask =
+        (locClientEventMaskType)(reqPayload.pRegEventsReq->eventRegMask);
+    }
+  }
+  return(status);
+}
+
+/** locClientSupportMsgCheck
+  @brief Sends a QMI_LOC_GET_SUPPORTED_MSGS_REQ_V02 message to the
+         location engine, and then receives a list of all services supported
+         by the engine. This function will check if the input service(s) form
+         the client is in the list or not. If the locClientSupportMsgCheck()
+         function is successful, the client should expect an result of
+         the service is supported or not recorded in supportedMsg.
+  @param [in] handle Handle returned by the locClientOpen()
+              function.
+  @param [in] supportedMsg   an integer used to record which
+                             message is supported
+
+  @return
+  One of the following error codes:
+  - 0 (eLOC_CLIENT_SUCCESS) -- On success.
+  - Non-zero error code (see \ref locClientStatusEnumType) -- On failure.
+*/
+
+locClientStatusEnumType locClientSupportMsgCheck(
+     locClientHandleType      handle,
+     const uint32_t*          msgArray,
+     uint32_t                 msgArrayLength,
+     uint64_t*                supportedMsg)
+{
+
+  // set to true if one client has checked the modem capability.
+  static bool isCheckedAlready = false;
+  /*
+  The 1st bit in supportedMsgChecked indicates if
+      QMI_LOC_EVENT_GEOFENCE_BATCHED_BREACH_NOTIFICATION_IND_V02
+      is supported or not;
+  The 2ed bit in supportedMsgChecked indicates if
+      QMI_LOC_GET_BATCH_SIZE_REQ_V02
+      is supported or not;
+  */
+  static uint64_t supportedMsgChecked = 0;
+
+  // Validate input arguments
+  if(msgArray == NULL || supportedMsg == NULL) {
+
+    LOC_LOGE("%s:%d]: Input argument/s NULL", __func__, __LINE__);
+    return eLOC_CLIENT_FAILURE_INVALID_PARAMETER;
+  }
+
+  if (isCheckedAlready) {
+    // already checked modem
+    LOC_LOGV("%s:%d]: Already checked. The supportedMsgChecked is %" PRId64 "\n",
+             __func__, __LINE__, supportedMsgChecked);
+    *supportedMsg = supportedMsgChecked;
+    return eLOC_CLIENT_SUCCESS;
+  }
+
+  locClientStatusEnumType status = eLOC_CLIENT_SUCCESS;
+  qmi_client_error_type rc = QMI_NO_ERR; //No error
+  qmiLocGetSupportMsgT_v02 resp;
+
+  uint32_t reqLen = 0;
+  void *pReqData = NULL;
+  locClientCallbackDataType *pCallbackData =
+        (locClientCallbackDataType *)handle;
+
+  // check the input handle for sanity
+   if( NULL == pCallbackData ||
+       NULL == pCallbackData->userHandle ||
+       pCallbackData != pCallbackData->pMe ) {
+     // did not find the handle in the client List
+     LOC_LOGE("%s:%d]: invalid handle \n",
+                   __func__, __LINE__);
+
+     return eLOC_CLIENT_FAILURE_GENERAL;
+   }
+
+  // NEXT call goes out to modem. We log the callflow before it
+  // actually happens to ensure the this comes before resp callflow
+  // back from the modem, to avoid confusing log order. We trust
+  // that the QMI framework is robust.
+
+  EXIT_LOG_CALLFLOW(%s, loc_get_v02_event_name(QMI_LOC_GET_SUPPORTED_MSGS_REQ_V02));
+  rc = qmi_client_send_msg_sync(
+      pCallbackData->userHandle,
+      QMI_LOC_GET_SUPPORTED_MSGS_REQ_V02,
+      pReqData,
+      reqLen,
+      &resp,
+      sizeof(resp),
+      LOC_CLIENT_ACK_TIMEOUT);
+
+  LOC_LOGV("%s:%d] qmi_client_send_msg_sync returned %d\n", __func__,
+                __LINE__, rc);
+
+  if (rc != QMI_NO_ERR)
+  {
+    LOC_LOGE("%s:%d]: send_msg_sync error: %d\n",__func__, __LINE__, rc);
+    return eLOC_CLIENT_FAILURE_GENERAL;
+  }
+
+  // map the QCCI response to Loc API v02 status
+  status = convertQmiResponseToLocStatus(&resp);
+
+  if(eLOC_CLIENT_SUCCESS == status)
+  {
+    LOC_LOGV("%s:%d]eLOC_CLIENT_SUCCESS == status\n", __func__, __LINE__);
+
+    // check every message listed in msgArray supported by modem or not
+    checkQmiMsgsSupported(msgArray, msgArrayLength, &resp, &supportedMsgChecked);
+
+    LOC_LOGV("%s:%d]: supportedMsgChecked is %" PRId64 "\n",
+             __func__, __LINE__, supportedMsgChecked);
+    *supportedMsg = supportedMsgChecked;
+    isCheckedAlready = true;
+    return status;
+  } else {
+
+    LOC_LOGE("%s:%d]: convertQmiResponseToLocStatus error: %d\n",
+            __func__, __LINE__, status);
+    return eLOC_CLIENT_FAILURE_GENERAL;
+  }
+}
+
+/** locClientGetSizeByRespIndId
+ *  @brief Get the size of the response indication structure,
+ *         from a specified id
+ *  @param [in]  respIndId
+ *  @param [out] pRespIndSize
+ *  @return true if resp ID was found; else false
+*/
+
+bool locClientGetSizeByRespIndId(uint32_t respIndId, size_t *pRespIndSize)
+{
+  size_t idx = 0, respIndTableSize = 0;
+
+  // Validate input arguments
+  if(pRespIndSize == NULL)
+  {
+    LOC_LOGE("%s:%d]: size argument NULL !");
+    return false;
+  }
+
+  respIndTableSize = (sizeof(locClientRespIndTable)/sizeof(locClientRespIndTableStructT));
+  for(idx=0; idx<respIndTableSize; idx++ )
+  {
+    if(respIndId == locClientRespIndTable[idx].respIndId)
+    {
+      // found
+      *pRespIndSize = locClientRespIndTable[idx].respIndSize;
+
+      LOC_LOGV("%s:%d]: resp ind Id %d size = %d\n", __func__, __LINE__,
+                    respIndId, (uint32_t)*pRespIndSize);
+      return true;
+    }
+  }
+
+  //not found
+  return false;
+}
+
+
+/** locClientGetSizeByEventIndId
+ *  @brief Gets the size of the event indication structure, from
+ *         a specified id
+ *  @param [in]  eventIndId
+ *  @param [out] pEventIndSize
+ *  @return true if event ID was found; else false
+*/
+bool locClientGetSizeByEventIndId(uint32_t eventIndId, size_t *pEventIndSize)
+{
+  size_t idx = 0, eventIndTableSize = 0;
+
+  // Validate input arguments
+  if(pEventIndSize == NULL)
+  {
+    LOC_LOGE("%s:%d]: size argument NULL !");
+    return false;
+  }
+
+  // look in the event table
+  eventIndTableSize =
+    (sizeof(locClientEventIndTable)/sizeof(locClientEventIndTableStructT));
+
+  for(idx=0; idx<eventIndTableSize; idx++ )
+  {
+    if(eventIndId == locClientEventIndTable[idx].eventId)
+    {
+      // found
+      *pEventIndSize = locClientEventIndTable[idx].eventSize;
+
+      LOC_LOGV("%s:%d]: event ind Id %d size = %d\n", __func__, __LINE__,
+                    eventIndId, (uint32_t)*pEventIndSize);
+      return true;
+    }
+  }
+  // not found
+  return false;
+}
diff --git a/gps/loc_api/loc_api_v02/loc_api_v02_client.h b/gps/loc_api/loc_api_v02/loc_api_v02_client.h
new file mode 100644
index 0000000..e1c85ed
--- /dev/null
+++ b/gps/loc_api/loc_api_v02/loc_api_v02_client.h
@@ -0,0 +1,1762 @@
+/* Copyright (c) 2011-2016, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of The Linux Foundation, nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @file loc_api_v02_client.h
+*/
+
+#ifndef LOC_API_V02_CLIENT_H
+#define LOC_API_V02_CLIENT_H
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/*=============================================================================
+ *
+ *                             DATA DECLARATION
+ *
+ *============================================================================*/
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "location_service_v02.h"  //QMI LOC Service data types definitions
+
+#include <stddef.h>
+
+/******************************************************************************
+ *  Constants and configuration
+ *****************************************************************************/
+
+/** @ingroup constants_macros
+  Specific value of #locClientHandleType, indicating an invalid handle. */
+#define LOC_CLIENT_INVALID_HANDLE_VALUE (NULL)
+
+
+/** @addtogroup data_types
+@{ */
+
+/** Location client handle used to represent a specific client. Negative values
+    are invalid handles.
+*/
+typedef void* locClientHandleType;
+
+/** Data type for events and event masks. */
+typedef uint64_t locClientEventMaskType;
+
+/** Location client status values.
+*/
+typedef enum
+{
+  eLOC_CLIENT_SUCCESS                              = 0,
+  /**< Request was successful. */
+
+  eLOC_CLIENT_FAILURE_GENERAL                      = 1,
+  /**< Failed because of a general failure. */
+
+  eLOC_CLIENT_FAILURE_UNSUPPORTED                  = 2,
+  /**< Failed because the service does not support the command. */
+
+  eLOC_CLIENT_FAILURE_INVALID_PARAMETER            = 3,
+  /**< Failed because the request contained invalid parameters. */
+
+  eLOC_CLIENT_FAILURE_ENGINE_BUSY                  = 4,
+  /**< Failed because the engine is busy. */
+
+  eLOC_CLIENT_FAILURE_PHONE_OFFLINE                = 5,
+  /**< Failed because the phone is offline. */
+
+  eLOC_CLIENT_FAILURE_TIMEOUT                      = 6,
+  /**< Failed because of a timeout. */
+
+  eLOC_CLIENT_FAILURE_SERVICE_NOT_PRESENT          = 7,
+  /**< Failed because the service is not present. */
+
+  eLOC_CLIENT_FAILURE_SERVICE_VERSION_UNSUPPORTED  = 8,
+  /**< Failed because the service version is unsupported. */
+
+  eLOC_CLIENT_FAILURE_CLIENT_VERSION_UNSUPPORTED  =  9,
+  /**< Failed because the service does not support client version. */
+
+  eLOC_CLIENT_FAILURE_INVALID_HANDLE               = 10,
+  /**< Failed because an invalid handle was specified. */
+
+  eLOC_CLIENT_FAILURE_INTERNAL                     = 11,
+  /**< Failed because of an internal error in the service. */
+
+  eLOC_CLIENT_FAILURE_NOT_INITIALIZED              = 12,
+  /**< Failed because the service has not been initialized. */
+
+  eLOC_CLIENT_FAILURE_NOT_ENOUGH_MEMORY             = 13
+  /**< Failed because there is not enough memory to do the operation. */
+
+}locClientStatusEnumType;
+
+/** Location client error values
+*/
+typedef enum
+{
+  eLOC_CLIENT_ERROR_SERVICE_UNAVAILABLE            = 1
+  /**< Service is no longer available. Upon getting this error, the client
+       must close the existing connection and reopen the connection. */
+
+}locClientErrorEnumType;
+
+
+/** Request messages the client can send to the location engine.
+
+  The following requests do not have any data associated, so they do not have a
+  payload structure defined:
+
+  - GetServiceRevision
+  - GetFixCriteria
+  - GetPredictedOrbitsDataSource
+  - GetPredictedOrbitsDataValidity
+  - GetEngineLock
+  - GetSbasConfigReq
+  - GetRegisteredEvents
+  - GetNmeaTypes
+  - GetLowPowerMode
+  - GetXtraTSessionControl
+  - GetRegisteredEvents
+  - GetOperationMode
+  - GetCradleMountConfig
+  - GetExternalPowerConfig
+  - GetSensorControlConfig
+  - GetSensorPerformanceControlConfiguration
+  - WWANOutOfServiceNotification
+*/
+typedef union
+{
+   const qmiLocInformClientRevisionReqMsgT_v02* pInformClientRevisionReq;
+   /**< Notifies the service about the revision the client is using.
+
+        The client does not receive any indications corresponding to this
+        request.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_INFORM_CLIENT_REVISION_REQ_V02. */
+
+   const qmiLocRegEventsReqMsgT_v02* pRegEventsReq;
+   /**< Changes the events the client is interested in receiving.
+
+        The client does not receive any indications corresponding to this
+        request.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_REG_EVENTS_REQ_V02. */
+
+   const qmiLocStartReqMsgT_v02* pStartReq;
+   /**< Starts a positioning session.
+
+        The client receives the following indications: position report,
+        satellite report, fix session report, and NMEA report (if applicable).
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_START_REQ_V02. */
+
+   const qmiLocStopReqMsgT_v02* pStopReq;
+   /**< Stops a positioning session. The client receives a fix session report
+        denoting that the fix session ended after this message was sent.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_STOP_REQ_V02. */
+
+   const qmiLocNiUserRespReqMsgT_v02* pNiUserRespReq;
+   /**< Informs the service about the user response for a network-initiated call.
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        QMI_LOC_NI_USER_RESPONSE_IND_V02.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_NI_USER_RESPONSE_REQ_V02. */
+
+   const qmiLocInjectPredictedOrbitsDataReqMsgT_v02* pInjectPredictedOrbitsDataReq;
+   /**< Injects the predicted orbits data into the service.
+
+        When all predicted orbits data parts have been injected, the client
+        receives the following indication containing a response:
+        QMI_LOC_INJECT_PREDICTED_ORBITS_DATA_IND_V02.
+
+        The client injects successive data parts without waiting for this
+        indication as long as locClientSendReq() returns successfully.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_INJECT_PREDICTED_ORBITS_DATA_REQ_V02. */
+
+   const qmiLocInjectUtcTimeReqMsgT_v02* pInjectUtcTimeReq;
+   /**< Injects UTC time into the service.
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        QMI_LOC_INJECT_UTC_TIME_IND_V02.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_INJECT_UTC_TIME_REQ_V02. */
+
+   const qmiLocInjectPositionReqMsgT_v02* pInjectPositionReq;
+   /**< Injects a position into the service.
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        QMI_LOC_INJECT_POSITION_IND_V02.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_INJECT_POSITION_REQ_V02. */
+
+   const qmiLocSetEngineLockReqMsgT_v02* pSetEngineLockReq;
+   /**< Sets the location engine lock.
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        QMI_LOC_SET_ENGINE_LOCK_IND_V02.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_SET_ENGINE_LOCK_REQ_V02. */
+
+   const qmiLocSetSbasConfigReqMsgT_v02* pSetSbasConfigReq;
+   /**< Sets the SBAS configuration.
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        QMI_LOC_SET_SBAS_CONFIG_IND_V02.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_SET_SBAS_CONFIG_REQ_V02 . */
+
+   const qmiLocSetNmeaTypesReqMsgT_v02* pSetNmeaTypesReq;
+   /**< Sets the NMEA types configuration.
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        QMI_LOC_SET_NMEA_TYPES_IND_V02.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_SET_NMEA_TYPES_REQ_V02. */
+
+   const qmiLocSetLowPowerModeReqMsgT_v02* pSetLowPowerModeReq;
+   /**< Sets the Low Power mode configuration.
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        QMI_LOC_SET_LOW_POWER_MODE_IND_V02.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_SET_LOW_POWER_MODE_REQ_V02. */
+
+   const qmiLocSetServerReqMsgT_v02* pSetServerReq;
+   /**< Sets the A-GPS server type and address.
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        QMI_LOC_SET_SERVER_IND_V02.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_SET_SERVER_REQ_V02. */
+
+   const qmiLocGetServerReqMsgT_v02* pGetServerReq;
+   /**< Gets the A-GPS server type and address.
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        QMI_LOC_GET_SERVER_IND_V02.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_GET_SERVER_REQ_V02. */
+
+   const qmiLocDeleteAssistDataReqMsgT_v02* pDeleteAssistDataReq;
+   /**< Deletes the aiding data from the engine.
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        QMI_LOC_DELETE_ASSIST_DATA_IND_V02.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_DELETE_ASSIST_DATA_REQ_V02. */
+
+   const qmiLocInjectApCacheDataReqMsgT_v02 *pInjectApCacheDataReq;
+   /**< Inject APcache data into the engine
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        QMI_LOC_INJECT_APCACHE_DATA_IND_V02.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_INJECT_APCACHE_DATA_REQ_V02. */
+
+   const qmiLocInjectApDoNotCacheDataReqMsgT_v02 *pInjectApDoNotCacheDataReq;
+   /**< Inject blacklist-Apcache data into the engine
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        QMI_LOC_INJECT_DONOTAPCACHE_DATA_IND_V02.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_INJECT_DONOTAPCACHE_DATA_REQ_V02. */
+
+
+   const qmiLocSetXtraTSessionControlReqMsgT_v02* pSetXtraTSessionControlReq;
+   /**< Sets XTRA-T session control in the engine.
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        QMI_LOC_SET_XTRA_T_SESSION_CONTROL_IND_V02.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_SET_XTRA_T_SESSION_CONTROL_REQ_V02. */
+
+   const qmiLocInjectWifiPositionReqMsgT_v02* pInjectWifiPositionReq;
+   /**< Injects a WiFi position into the engine.
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        QMI_LOC_INJECT_WIFI_POSITION_IND_V02.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_INJECT_WIFI_POSITION_REQ_V02. */
+
+   const qmiLocNotifyWifiStatusReqMsgT_v02* pNotifyWifiStatusReq;
+   /**< Notifies the engine about the WiFi status.
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        QMI_LOC_NOTIFY_WIFI_STATUS_IND_V02.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_NOTIFY_WIFI_STATUS_REQ_V02. */
+
+   const qmiLocSetOperationModeReqMsgT_v02* pSetOperationModeReq;
+   /**< Sets the engine Operation mode.
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        QMI_LOC_SET_OPERATION_MODE_IND_V02.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_SET_OPERATION_MODE_REQ_V02. */
+
+   const qmiLocSetSpiStatusReqMsgT_v02* pSetSpiStatusReq;
+   /**< Sends the stationary position status to the engine.
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        QMI_LOC_SET_SPI_STATUS_IND_V02.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_SET_SPI_STATUS_REQ_V02. */
+
+   const qmiLocInjectSensorDataReqMsgT_v02* pInjectSensorDataReq;
+   /**< Injects sensor data into the engine.
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        QMI_LOC_INJECT_SENSOR_DATA_IND_V02.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_INJECT_SENSOR_DATA_REQ_V02. */
+
+   const qmiLocInjectTimeSyncDataReqMsgT_v02* pInjectTimeSyncReq;
+   /**< Injects time synchronization information into the engine.
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        QMI_LOC_INJECT_TIME_SYNC_DATA_IND_V02.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_INJECT_TIME_SYNC_DATA_REQ_V02. */
+
+   const qmiLocSetCradleMountConfigReqMsgT_v02* pSetCradleMountConfigReq;
+   /**< Sets the cradle mount state information in the engine.
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        SET_CRADLE_MOUNT_CONFIG_REQ_V02.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        SET_CRADLE_MOUNT_CONFIG_IND_V02. */
+
+   const qmiLocSetExternalPowerConfigReqMsgT_v02* pSetExternalPowerConfigReq;
+   /**< Sets external power configuration state in the engine.
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        QMI_LOC_SET_EXTERNAL_POWER_CONFIG_IND_V02.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_SET_EXTERNAL_POWER_CONFIG_REQ_V02. */
+
+   const qmiLocInformLocationServerConnStatusReqMsgT_v02*
+     pInformLocationServerConnStatusReq;
+   /**< Informs the engine about the connection status to the location server.
+
+        This can be sent in response to a
+        QMI_LOC_EVENT_LOCATION_SERVER_CONNECTION_REQ_IND_V02 request. The
+        service sends back a QMI_LOC_INFORM_LOCATION_SERVER_CONN_STATUS_IND_V02
+        response indication for this request.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_INFORM_LOCATION_SERVER_CONN_STATUS_REQ_V02. */
+
+   const qmiLocSetProtocolConfigParametersReqMsgT_v02*
+     pSetProtocolConfigParametersReq;
+   /**< Sets the protocol configuration parameters in the engine.
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        QMI_LOC_SET_PROTOCOL_CONFIG_PARAMETERS_IND_V02.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_SET_PROTOCOL_CONFIG_PARAMETERS_REQ_V02. */
+
+   const qmiLocGetProtocolConfigParametersReqMsgT_v02*
+     pGetProtocolConfigParametersReq;
+   /**< Retrieves protocol configuration parameters from the engine.
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        QMI_LOC_GET_PROTOCOL_CONFIG_PARAMETERS_IND_V02.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_GET_PROTOCOL_CONFIG_PARAMETERS_REQ_V02. */
+
+   const qmiLocSetSensorControlConfigReqMsgT_v02*
+     pSetSensorControlConfigReq;
+   /**< Sets the sensor control configuration parameters in the engine.
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        QMI_LOC_SET_SENSOR_CONTROL_CONFIG_IND_V02.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_SET_SENSOR_CONTROL_CONFIG_REQ_V02. */
+
+   const qmiLocSetSensorPerformanceControlConfigReqMsgT_v02*
+      pSetSensorPerformanceControlConfigReq;
+   /**< Sets the sensor performance configuration parameters in the engine.
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        QMI_LOC_SET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_IND_V02.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_SET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_REQ_V02. */
+
+   const qmiLocGetSensorPropertiesReqMsgT_v02* pGetSensorPropertiesReq;
+   /**< Retrieves the sensor properties from the engine.
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        QMI_LOC_GET_SENSOR_PROPERTIES_IND_V02.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_GET_SENSOR_PROPERTIES_REQ_V02. */
+
+   const qmiLocSetSensorPropertiesReqMsgT_v02* pSetSensorPropertiesReq;
+   /**< Sets the sensor properties in the engine.
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        QMI_LOC_SET_SENSOR_PROPERTIES_IND_V02.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_SET_SENSOR_PROPERTIES_REQ_V02. */
+
+   const qmiLocInjectSuplCertificateReqMsgT_v02* pInjectSuplCertificateReq;
+   /**< Injects a SUPL certificate into the engine.
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        QMI_LOC_INJECT_SUPL_CERTIFICATE_IND_V02.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_INJECT_SUPL_CERTIFICATE_REQ_V02. */
+
+   const qmiLocDeleteSuplCertificateReqMsgT_v02* pDeleteSuplCertificateReq;
+   /**< Deletes a SUPL certificate from the engine.
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        QMI_LOC_DELETE_SUPL_CERTIFICATE_IND_V02.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_DELETE_SUPL_CERTIFICATE_REQ_V02. */
+
+   const qmiLocSetPositionEngineConfigParametersReqMsgT_v02*
+     pSetPositionEngineConfigParametersReq;
+   /**< Sets position engine configuration.
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        QMI_LOC_SET_POSITION_ENGINE_CONFIG_PARAMETERS_IND _V02.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_SET_POSITION_ENGINE_CONFIG_PARAMETERS_REQ_V02. */
+
+   const qmiLocGetPositionEngineConfigParametersReqMsgT_v02*
+     pGetPositionEngineConfigParametersReq;
+   /**< Gets position engine configuration.
+
+         If the request is accepted by the service, the client receives the
+         following indication containing a response:
+         QMI_LOC_GET_POSITION_ENGINE_CONFIG_PARAMETERS_IND_V02.
+
+         To send this request, set the reqId field in locClientSendReq() to
+         QMI_LOC_GET_POSITION_ENGINE_CONFIG_PARAMETERS_REQ_V02. */
+
+   const qmiLocAddCircularGeofenceReqMsgT_v02* pAddCircularGeofenceReq;
+   /**< Adds a circular geofence.
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        QMI_LOC_ADD_CIRCULAR_GEOFENCE_IND_V02.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_ADD_CIRCULAR_GEOFENCE_REQ_V02 */
+
+   const qmiLocDeleteGeofenceReqMsgT_v02* pDeleteGeofenceReq;
+   /**< Deletes a geofence.
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        QMI_LOC_DELETE_GEOFENCE_IND_V02.
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_DELETE_GEOFENCE_REQ_V02 */
+
+   const qmiLocQueryGeofenceReqMsgT_v02* pQueryGeofenceReq;
+   /**< Queries a geofence.
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        QMI_LOC_QUERY_GEOFENCE_IND_V02
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_QUERY_GEOFENCE_REQ_V02. */
+
+    const qmiLocEditGeofenceReqMsgT_v02* pEditGeofenceReq;
+    /**< Edits geofence parameters.
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        QMI_LOC_EDIT_GEOFENCE_IND_V02
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_EDIT_GEOFENCE_REQ_V02. */
+
+    const qmiLocGetBestAvailablePositionReqMsgT_v02*
+      pGetBestAvailablePositionReq;
+    /**< Get the best available position from location engine
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        QMI_LOC_GET_BEST_AVAILABLE_POSITION_IND_V02
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_GET_BEST_AVAILABLE_POSITION_REQ_V02. @newpagetable */
+
+    const qmiLocSecureGetAvailablePositionReqMsgT_v02*
+         pSecureGetBestAvailablePositionReq;
+       /**< Get the best available position from location engine
+
+           If the request is accepted by the service, the client receives the
+           following indication containing a response:
+           QMI_LOC_GET_BEST_AVAILABLE_POSITION_IND_V02
+
+           To send this request, set the reqId field in locClientSendReq() to
+           QMI_LOC_GET_BEST_AVAILABLE_POSITION_REQ_V02. @newpagetable */
+
+    const qmiLocInjectMotionDataReqMsgT_v02* pInjectMotionDataReq;
+    /**< Inject motion data in the location engine
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        QMI_LOC_INJECT_MOTION_DATA_IND_V02
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_INJECT_MOTION_DATA_REQ_V02 */
+
+    const qmiLocGetNiGeofenceIdListReqMsgT_v02* pGetNiGeofenceIdListReq;
+    /**< Get the list of Network Initiated Geofences from the location engine.
+
+        If the request is accepted by the service, the client receives the
+        following indication containing a response:
+        QMI_LOC_GET_NI_GEOFENCE_ID_LIST_IND_V02
+
+        To send this request, set the reqId field in locClientSendReq() to
+        QMI_LOC_GET_NI_GEOFENCE_ID_LIST_REQ_V02 */
+
+    const qmiLocInjectGSMCellInfoReqMsgT_v02 *pInjectGSMCellInfoReq;
+    /**< Inject GSM Cell Information into the location engine.
+         If the request is accepted by the service, the client receives the
+         following indication containing a response:
+         QMI_LOC_INJECT_GSM_CELL_INFO_IND_V02
+
+         To send this request, set the reqId field in locClientSendReq() to
+         QMI_LOC_INJECT_GSM_CELL_INFO_REQ_V02 */
+
+    const qmiLocInjectNetworkInitiatedMessageReqMsgT_v02
+      *pInjectNetworkInitiatedMessageReq;
+    /**< Inject Network Initiated Message into the location engine.
+         If the request is accepted by the service, the client receives the
+         following indication containing a response:
+         QMI_LOC_INJECT_NETWORK_INITIATED_MESSAGE_IND_V02
+
+         To send this request, set the reqId field in locClientSendReq() to
+         QMI_LOC_INJECT_NETWORK_INITIATED_MESSAGE_REQ_V02 */
+
+    const void *pWWANOutOfServiceNotificationReq;
+
+    const qmiLocPedometerReportReqMsgT_v02 *pPedometerReportReq;
+    /**< Send pedometer data to the location engine. If the request is
+         accepted by the service, the client receives the following
+         indication containing a response:
+         QMI_LOC_PEDOMETER_REPORT_IND_V02
+
+         To send this request, set the reqId field in locClientSendReq() to
+         QMI_LOC_PEDOMETER_REPORT_REQ_V02 */
+
+    const qmiLocInjectWCDMACellInfoReqMsgT_v02 *pInjectWCDMACellInfoReq;
+    const qmiLocInjectTDSCDMACellInfoReqMsgT_v02 *pInjectTDSCDMACellInfoReq;
+    const qmiLocInjectSubscriberIDReqMsgT_v02 *pInjectSubscriberIDReq;
+    const qmiLocInjectWifiApDataReqMsgT_v02 *pInjectWifiApDataReq;
+    const qmiLocNotifyWifiAttachmentStatusReqMsgT_v02 *pNotifyWifiAttachmentStatusReq;
+    const qmiLocNotifyWifiEnabledStatusReqMsgT_v02 *pNotifyWifiEnabledStatusReq;
+
+    const qmiLocReadFromBatchReqMsgT_v02 *pReadFromBatchReq;
+    const qmiLocGetBatchSizeReqMsgT_v02 *pGetBatchSizeReq;
+    const qmiLocStartBatchingReqMsgT_v02 *pStartBatchingReq;
+    const qmiLocStopBatchingReqMsgT_v02 *pStopBatchingReq;
+    const qmiLocReleaseBatchReqMsgT_v02 *pReleaseBatchReq;
+
+    const qmiLocInjectVehicleSensorDataReqMsgT_v02 *pInjectVehicleSensorDataReq;
+
+    /**< Send vehicle sensor data to the location engine. If the request is
+         accepted by the service, the client receives the following
+         indication containing a response:
+         QMI_LOC_INJECT_VEHICLE_SENSOR_DATA_IND_V02
+
+         To send this request, set the reqId field in locClientSendReq() to
+         QMI_LOC_INJECT_VEHICLE_SENSOR_DATA_REQ_V02 */
+
+    const qmiLocSetPremiumServicesCfgReqMsgT_v02 *pSetPremiumServicesCfgReq;
+    /*QMI_LOC_SET_PREMIUM_SERVICES_CONFIG_REQ_V02*/
+
+    const qmiLocGetAvailWwanPositionReqMsgT_v02 *pGetAvailWwanPositionReq;
+    /*QMI_LOC_GET_AVAILABLE_WWAN_POSITION_REQ_V02*/
+
+    const qmiLocSetXtraVersionCheckReqMsgT_v02 *pSetXtraVersionCheckReq;
+
+    const qmiLocGdtUploadBeginStatusReqMsgT_v02* pGdtUploadBeginStatusReq;
+    /* QMI_LOC_GDT_UPLOAD_BEGIN_STATUS_REQ_V02 */
+
+    const qmiLocGdtUploadEndReqMsgT_v02* pGdtUploadEndReq;
+    /* QMI_LOC_GDT_UPLOAD_END_REQ_V02*/
+
+    const qmiLocInjectGtpClientDownloadedDataReqMsgT_v02 *pInjectGtpClientDownloadedDataReq;
+    /* QMI_LOC_INJECT_GTP_CLIENT_DOWNLOADED_DATA_REQ_V02 */
+
+    const qmiLocSetGNSSConstRepConfigReqMsgT_v02 *pSetGNSSConstRepConfigReq;
+    /*QMI_LOC_SET_GNSS_CONSTELL_REPORT_CONFIG_V02*/
+
+    const qmiLocStartDbtReqMsgT_v02 *pStartDbtReq;
+    /*QMI_LOC_START_DBT_REQ_V02*/
+
+    const qmiLocStopDbtReqMsgT_v02 *pStopDbtReq;
+    /*QMI_LOC_STOP_DBT_REQ_V02*/
+
+    const qmiLocInjectTimeZoneInfoReqMsgT_v02 *pInjectTimeZoneInfoReq;
+    /*QMI_LOC_INJECT_TIME_ZONE_INFO*/
+
+    const qmiLocQueryAonConfigReqMsgT_v02 *pQueryAonConfigReq;
+    /*QMI_LOC_QUERY_AON_CONFIG_REQ_V02*/
+
+    const qmiLocGetSupportedFeatureReqMsgT_v02 *pGetSupportedFeatureReq;
+    /* QMI_LOC_GET_SUPPORTED_FEATURE_REQ_V02*/
+
+    const qmiLocGtpApStatusReqMsgT_v02* pGtpApStatusReq;
+    /* QMI_LOC_GTP_AP_STATUS_REQ_V02 */
+
+    const qmiLocGdtDownloadBeginStatusReqMsgT_v02* pGdtDownloadBeginStatusReq;
+    /* QMI_LOC_GDT_DOWNLOAD_BEGIN_STATUS_REQ_V02 */
+
+    const qmiLocGdtDownloadReadyStatusReqMsgT_v02* pGdtDownloadReadyStatusReq;
+    /* QMI_LOC_GDT_DOWNLOAD_READY_STATUS_REQ_V02 */
+
+    const qmiLocGdtReceiveDoneStatusReqMsgT_v02* pGdtReceiveDoneStatusReq;
+    /* QMI_LOC_GDT_RECEIVE_DONE_STATUS_REQ_V02 */
+
+    const qmiLocGdtDownloadEndStatusReqMsgT_v02* pGdtDownloadEndStatusReq;
+    /* QMI_LOC_GDT_DOWNLOAD_END_STATUS_REQ_V02*/
+
+    const qmiLocDeleteGNSSServiceDataReqMsgT_v02* pDeleteGNSSServiceDataReq;
+    /* QMI_LOC_DELETE_GNSS_SERVICE_DATA_REQ_V02*/
+
+    // XTRA Client 2.0
+    const qmiLocInjectXtraDataReqMsgT_v02 *pInjectXtraDataReq;
+    /*QMI_LOC_INJECT_XTRA_DATA_REQ_V02*/
+
+    const qmiLocInjectXtraPcidReqMsgT_v02 *pInjectXtraPcidReq;
+    /*QMI_LOC_INJECT_XTRA_PCID_REQ_V02*/
+}locClientReqUnionType;
+
+
+/** Event indications that are sent by the service.
+*/
+typedef union
+{
+   const qmiLocEventPositionReportIndMsgT_v02* pPositionReportEvent;
+   /**< Contains the position information.
+
+        This event is generated after QMI_LOC_START_REQ_V02 is sent. If
+        periodic fix criteria is specified, this event is generated multiple
+        times periodically at the specified rate until QMI_LOC_STOP_REQ_V02 is
+        sent.
+
+        The eventIndId field in the event indication callback is set to
+        QMI_LOC_EVENT_POSITION_REPORT_IND_V02. */
+
+   const qmiLocEventGnssSvInfoIndMsgT_v02* pGnssSvInfoReportEvent;
+   /**< Contains the GNSS satellite information.
+
+        This event is generated after QMI_LOC_START_REQ_V02 is sent. This event
+        is generated at 1 Hz if the location engine is tracking satellites to
+        make a location fix.
+
+        The eventIndId field in the event indication callback is set to
+        QMI_LOC_EVENT_GNSS_INFO_IND_V02. */
+
+   const qmiLocEventNmeaIndMsgT_v02* pNmeaReportEvent;
+   /**< Contains an NMEA report sentence.
+
+        The entire NMEA report consisting of multiple sentences is sent at a
+        1 Hz rate. This event is generated after QMI_LOC_START_REQ_V02 is sent.
+
+        The eventIndId field in the event indication callback is set to
+        QMI_LOC_EVENT_NMEA_IND_V02. */
+
+   const qmiLocEventNiNotifyVerifyReqIndMsgT_v02* pNiNotifyVerifyReqEvent;
+   /**< Notifies a location client when the network triggers a positioning
+        request to the mobile.
+
+        Upon getting this event, the location client displays the
+        network-initiated fix request in a dialog and prompts the user to
+        accept or deny the request. The client responds to this request with
+        the message QMI_LOC_NI_USER_RESPONSE_REQ_V02.
+
+        The eventIndId field in the event indication callback is set to
+        QMI_LOC_EVENT_NI_NOTIFY_VERIFY_REQ_IND_V02. */
+
+   const qmiLocEventInjectTimeReqIndMsgT_v02* pInjectTimeReqEvent;
+   /**< Asks the client for time assistance.
+
+        The client responds to this request with the message
+        QMI_LOC_INJECT_UTC_TIME_REQ_V02.
+
+        The eventIndId field in the event indication callback is
+        set to QMI_LOC_EVENT_INJECT_TIME_REQ_IND_V02. */
+
+   const qmiLocEventInjectPredictedOrbitsReqIndMsgT_v02*
+         pInjectPredictedOrbitsReqEvent;
+   /**< Asks the client for predicted orbits data assistance.
+
+        The client responds to this request with the message
+        QMI_LOC_INJECT_PREDICTED_ORBITS_DATA_REQ_V02.
+
+        The eventIndId field in the event indication callback is set to
+        QMI_LOC_EVENT_INJECT_PREDICTED_ORBITS_REQ_IND_V02. */
+
+   const qmiLocEventInjectPositionReqIndMsgT_v02* pInjectPositionReqEvent;
+   /**< Asks the client for position assistance.
+
+        The client responds to this request with the message
+        QMI_LOC_INJECT_POSITION_REQ_V02.
+
+        The eventIndId field in the event indication callback is set to
+        QMI_LOC_EVENT_INJECT_POSITION_REQ_IND_V02. */
+
+   const qmiLocEventEngineStateIndMsgT_v02* pEngineState;
+   /**< Sent by the engine whenever it turns on or off.
+
+        The eventIndId field in the event indication callback is set to
+        QMI_LOC_EVENT_ENGINE_STATE_IND_V02. */
+
+   const qmiLocEventFixSessionStateIndMsgT_v02* pFixSessionState;
+   /**< Sent by the engine when a location session begins or ends.
+
+        The eventIndId field in the event indication callback is set to
+        QMI_LOC_EVENT_FIX_SESSION_STATE_IND_V02. */
+
+   const qmiLocEventWifiReqIndMsgT_v02* pWifiReqEvent;
+   /**< Sent by the engine when it needs WiFi support.
+
+        The eventIndId field in the event indication callback is set to
+        QMI_LOC_EVENT_WIFI_REQ_IND_V02. */
+
+   const qmiLocEventSensorStreamingReadyStatusIndMsgT_v02*
+          pSensorStreamingReadyStatusEvent;
+   /**< Notifies the client that the engine is ready to accept sensor data.
+
+        The eventIndId field in the event indication callback is set to
+        QMI_LOC_EVENT_SENSOR_STREAMING_READY_STATUS_IND_V02. */
+
+   const qmiLocEventTimeSyncReqIndMsgT_v02* pTimeSyncReqEvent;
+   /**< Sent by the engine when it needs to synchronize its time with the sensor
+        processor time.
+
+        The eventIndId field in the event indication callback is set to
+        QMI_LOC_EVENT_TIME_SYNC_REQ_IND_V02. */
+
+   const qmiLocEventSetSpiStreamingReportIndMsgT_v02*
+     pSetSpiStreamingReportEvent;
+   /**< Asks the client to start/stop sending a Stationary Position Indicator
+        (SPI) stream.
+
+        The eventIndId field in the event indication callback is set to
+        QMI_LOC_SET_SPI_STREAMING_REPORT_IND_V02. */
+
+   const qmiLocEventLocationServerConnectionReqIndMsgT_v02*
+      pLocationServerConnReqEvent;
+   /**< Sent by the engine to ask the client to open or close a connection to
+        a location server.
+
+        The client responds to this request by sending the
+        QMI_LOC_INFORM_LOCATION_SERVER_CONN_STATUS_REQ_V02 message.
+
+        The eventIndId field in the event indication callback is set to
+        QMI_LOC_EVENT_LOCATION_SERVER_CONNECTION_REQ_IND_V02. */
+
+   const qmiLocEventNiGeofenceNotificationIndMsgT_v02*
+     pNiGeofenceNotificationEvent;
+   /**< Sent by the engine to notify the client about changes to a
+        network-initiated geofence.
+
+        The eventIndId field in the event indication callback is set to
+        QMI_LOC_EVENT_NI_GEOFENCE_NOTIFICATION_IND_V02. */
+
+   const qmiLocEventGeofenceGenAlertIndMsgT_v02* pGeofenceGenAlertEvent;
+   /**< Sent by the engine to notify the client about updates that may
+        affect a geofence operation.
+
+        The eventIndId field in the event indication callback is set to
+        QMI_LOC_EVENT_GEOFENCE_GEN_ALERT_IND_V02. */
+
+   const qmiLocEventGeofenceBreachIndMsgT_v02* pGeofenceBreachEvent;
+   /**< Sent by the engine to notify the client about a geofence breach
+        event.
+
+        The eventIndId field in the event indication callback is set to
+        QMI_LOC_EVENT_GEOFENCE_BREACH_NOTIFICATION_IND_V02. @newpagetable */
+
+   const qmiLocEventGeofenceBatchedBreachIndMsgT_v02* pGeofenceBatchedBreachEvent;
+   /**< Sent by the engine to notify the client about a geofence breach
+        event.
+
+        The eventIndId field in the event indication callback is set to
+        QMI_LOC_EVENT_GEOFENCE_BATCHED_BREACH_NOTIFICATION_IND_V02. @newpagetable */
+
+   const qmiLocEventPedometerControlIndMsgT_v02* pPedometerControlEvent;
+   /**< Sent by the engine to recommend how pedometer data is sent to the
+        location engine.
+        The eventIndId field in the event indication callback is set to
+        QMI_LOC_EVENT_PEDOMETER_CONTROL_IND_V02. @newpagetable */
+
+   const qmiLocEventMotionDataControlIndMsgT_v02* pMotionDataControlEvent;
+   /**< Sent by the engine to recommend how motion data is sent to the
+        location engine.
+        The eventIndId field in the event indication callback is set to
+        QMI_LOC_EVENT_MOTION_DATA_CONTROL_IND_V02. @newpagetable */
+
+   const qmiLocEventInjectWifiApDataReqIndMsgT_v02* pWifiApDataReqEvent;
+   const qmiLocEventLiveBatchedPositionReportIndMsgT_v02* pBatchPositionReportEvent;
+   /**< Sent by the engine to notify the client that live batch location
+        is ready, and the location info.
+
+        The eventIndId field in the event indication callback is set to
+        QMI_LOC_EVENT_LIVE_BATCHED_POSITION_REPORT_IND_V02. */
+
+   const qmiLocEventBatchFullIndMsgT_v02* pBatchCount;
+   /**< Sent by the engine to notify the client that batch location is
+        full, and how many location are available to read.
+
+        The eventIndId field in the event indication callback is set to
+        QMI_LOC_EVENT_BATCH_FULL_IND_V02. */
+
+   const qmiLocEventVehicleDataReadyIndMsgT_v02* pVehicleDataReadyEvent;
+   /**< Sent by the engine to recommend how vehicle sensor data is
+        sent to the location engine.
+        The eventIndId field in the event indication callback is set to
+        QMI_LOC_EVENT_VEHICLE_DATA_READY_STATUS_IND_V02. @newpagetable */
+
+   const qmiLocEventGeofenceProximityIndMsgT_v02* pGeofenceProximityEvent;
+   /**< Sent by the engine to notify the client about a geofence proximity
+        event.
+
+        The eventIndId field in the event indication callback is set to
+        QMI_LOC_EVENT_GEOFENCE_PROXIMITY_NOTIFICATION_IND_V02. @newpagetable */
+
+   const qmiLocEventGnssSvMeasInfoIndMsgT_v02* pGnssSvRawInfoEvent;
+
+   /**< Sent by the engine when GNSS measurements are available
+        The eventIndId field in the event indication callback is set to
+        QMI_LOC_EVENT_GNSS_MEASUREMENT_REPORT_IND_V02. @newpagetable */
+
+   const qmiLocEventGnssSvPolyIndMsgT_v02* pGnssSvPolyInfoEvent;
+
+   /**< Sent by the engine when GNSS measurements are available
+        The eventIndId field in the event indication callback is set to
+        QMI_LOC_EVENT_SV_POLYNOMIAL_REPORT_IND_V02. @newpagetable */
+
+   const qmiLocEventGdtUploadBeginStatusReqIndMsgT_v02* pGdtUploadBeginEvent;
+   /**< Sent by the engine to notify the client about a GDT upload
+        begine event.
+
+       The eventIndId field in the event indication callback is set to
+       QMI_LOC_EVENT_GDT_UPLOAD_BEGIN_STATUS_REQ_IND_V02. @newpagetable */
+
+   const qmiLocEventGdtUploadEndReqIndMsgT_v02* pGdtUploadEndEvent;
+   /**< Sent by the engine to notify the client about a GDT upload
+        end event.
+
+       The eventIndId field in the event indication callback is set to
+       QMI_LOC_EVENT_GDT_UPLOAD_END_REQ_IND_V02. @newpagetable */
+
+   const qmiLocEventDbtPositionReportIndMsgT_v02 *pDbtPositionReportEvent;
+   /**< Sent by the engine to notify the client of a distance based
+        tracking position report.
+        QMI_LOC_EVENT_DBT_POSITION_REPORT_IND_V02*/
+
+   const qmiLocEventDbtSessionStatusIndMsgT_v02 *pDbtSessionStatusEvent;
+   /**< Sent by the engine to notify the client of the status of the
+      DBT session.
+      QMI_LOC_EVENT_DBT_SESSION_STATUS_IND_V02*/
+
+   const qmiLocEventGeofenceBatchedDwellIndMsgT_v02 *pGeofenceBatchedDwellEvent;
+   /**< Sent by the engine to notify the client of the dwell time inside
+      or outside of a Geofence for a specified time.
+      QMI_LOC_EVENT_GEOFENCE_BATCHED_DWELL_NOTIFICATION_IND_V02*/
+
+   const qmiLocEventGetTimeZoneReqIndMsgT_v02 *pGetTimeZoneReqEvent;
+   /**< Sent by the engine to request injection of time zone info
+      QMI_LOC_EVENT_GET_TIME_ZONE_INFO_IND_V02>*/
+
+   const qmiLocEventBatchingStatusIndMsgT_v02* pBatchingStatusEvent;
+   /**< Sent by the engine to notify the control point of the batching status.
+        The eventIndId field in the event indication callback is set to
+        QMI_LOC_EVENT_BATCHING_STATUS_IND_V02. */
+
+   const qmiLocEventGdtDownloadBeginReqIndMsgT_v02 *pGdtDownloadBeginReqEvent;
+   /**< Sent by the engine to notify the client about a GDT download
+        begin event.
+        QMI_LOC_EVENT_GDT_DOWNLOAD_BEGIN_REQ_IND_V02. */
+
+   const qmiLocEventGdtReceiveDoneIndMsgT_v02 *pGdtReceiveDoneEvent;
+   /**< Sent by the engine to notify the client about a GDT download
+        receive done event.
+        QMI_LOC_EVENT_GDT_RECEIVE_DONE_IND_V02. */
+
+   const qmiLocEventGdtDownloadEndReqIndMsgT_v02 *pGdtDownloadEndReqEvent;
+   /**< Sent by the engine to notify the client about a GDT download
+        end event.
+        QMI_LOC_EVENT_GDT_DOWNLOAD_END_REQ_IND_V02. */
+
+}locClientEventIndUnionType;
+
+
+/** Response indications that are sent by the service.
+*/
+typedef union
+{
+   const qmiLocGetServiceRevisionIndMsgT_v02* pGetServiceRevisionInd;
+   /**< Response to the QMI_LOC_GET_SERVICE_REVISION_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_GET_SERVICE_REVISION_IND_V02. */
+
+   const qmiLocGetFixCriteriaIndMsgT_v02* pGetFixCriteriaInd;
+   /**< Response to the QMI_LOC_GET_FIX_CRITERIA_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_GET_FIX_CRITERIA_IND_V02. */
+
+   const qmiLocNiUserRespIndMsgT_v02* pNiUserRespInd;
+   /**< Response to the QMI_LOC_NI_USER_RESPONSE_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_NI_USER_RESPONSE_IND_V02. */
+
+   const qmiLocInjectPredictedOrbitsDataIndMsgT_v02*
+     pInjectPredictedOrbitsDataInd;
+   /**< Sent after a predicted orbits data part has been successfully injected.
+
+        The client waits for this indication before injecting the next part.
+        This indication is sent in response to
+        QMI_LOC_INJECT_PREDICTED_ORBITS_DATA_REQ_V02.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_INJECT_PREDICTED_ORBITS_DATA_IND_V02. */
+
+   const qmiLocGetPredictedOrbitsDataSourceIndMsgT_v02*
+      pGetPredictedOrbitsDataSourceInd;
+   /**< Response to the QMI_LOC_GET_PREDICTED_ORBITS_DATA_SOURCE_REQ_V02
+        request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_GET_PREDICTED_ORBITS_DATA_SOURCE_IND_V02. */
+
+   const qmiLocGetPredictedOrbitsDataValidityIndMsgT_v02*
+     pGetPredictedOrbitsDataValidityInd;
+   /**< Response to the QMI_LOC_GET_PREDICTED_ORBITS_DATA_VALIDITY_REQ_V02
+        request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_GET_PREDICTED_ORBITS_DATA_VALIDITY_IND_V02. */
+
+   const qmiLocInjectUtcTimeIndMsgT_v02* pInjectUtcTimeInd;
+   /**< Response to the QMI_LOC_INJECT_UTC_TIME_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_INJECT_UTC_TIME_IND_V02. */
+
+   const qmiLocInjectPositionIndMsgT_v02* pInjectPositionInd;
+   /**< Response to the QMI_LOC_INJECT_POSITION_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_INJECT_POSITION_IND_V02. */
+
+   const qmiLocSetEngineLockIndMsgT_v02* pSetEngineLockInd;
+   /**< Response to the QMI_LOC_SET_ENGINE_LOCK_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_SET_ENGINE_LOCK_IND_V02. */
+
+   const qmiLocGetEngineLockIndMsgT_v02* pGetEngineLockInd;
+   /**< Response to the QMI_LOC_GET_ENGINE_LOCK_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_GET_ENGINE_LOCK_IND_V02. */
+
+   const qmiLocSetSbasConfigIndMsgT_v02* pSetSbasConfigInd;
+   /**< Response to the QMI_LOC_SET_SBAS_CONFIG_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_SET_SBAS_CONFIG_IND_V02. */
+
+   const qmiLocGetSbasConfigIndMsgT_v02* pGetSbasConfigInd;
+   /**< Response to the QMI_LOC_GET_SBAS_CONFIG_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_GET_SBAS_CONFIG_IND_V02. */
+
+   const qmiLocSetNmeaTypesIndMsgT_v02* pSetNmeaTypesInd;
+   /**< Response to the QMI_LOC_SET_NMEA_TYPES_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_SET_NMEA_TYPES_IND_V02. */
+
+   const qmiLocGetNmeaTypesIndMsgT_v02* pGetNmeaTypesInd;
+   /**< Response to the QMI_LOC_GET_NMEA_TYPES_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_GET_NMEA_TYPES_IND_V02. */
+
+   const qmiLocSetLowPowerModeIndMsgT_v02* pSetLowPowerModeInd;
+   /**< Response to the QMI_LOC_SET_LOW_POWER_MODE_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_SET_LOW_POWER_MODE_IND_V02. */
+
+   const qmiLocGetLowPowerModeIndMsgT_v02* pGetLowPowerModeInd;
+   /**< Response to the QMI_LOC_GET_LOW_POWER_MODE_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_GET_LOW_POWER_MODE_IND_V02. */
+
+   const qmiLocSetServerIndMsgT_v02* pSetServerInd;
+   /**< Response to the QMI_LOC_SET_SERVER_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_SET_SERVER_IND_V02. */
+
+   const qmiLocGetServerIndMsgT_v02* pGetServerInd;
+   /**< Response to the QMI_LOC_GET_SERVER_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_GET_SERVER_IND_V02. */
+
+   const qmiLocDeleteAssistDataIndMsgT_v02* pDeleteAssistDataInd;
+   /**< Response to the QMI_LOC_DELETE_ASSIST_DATA_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_DELETE_ASSIST_DATA_IND_V02. */
+
+   const qmiLocInjectApCacheDataIndMsgT_v02 *pInjectApCacheDataInd;
+   /**< Response to the QMI_LOC_INJECT_APCACHE_DATA_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_INJECT_APCACHE_DATA_IND_V02. */
+
+   const qmiLocInjectApDoNotCacheDataIndMsgT_v02 *pInjectApDoNotCacheDataInd;
+   /**< Response to the QMI_LOC_INJECT_DONOTAPCACHE_DATA_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_INJECT_DONOTAPCACHE_DATA_IND_V02. */
+
+   const qmiLocSetXtraTSessionControlIndMsgT_v02* pSetXtraTSessionControlInd;
+   /**< Response to the QMI_LOC_SET_XTRA_T_SESSION_CONTROL_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_SET_XTRA_T_SESSION_CONTROL_IND_V02. */
+
+   const qmiLocGetXtraTSessionControlIndMsgT_v02* pGetXtraTSessionControlInd;
+   /**< Response to the QMI_LOC_GET_XTRA_T_SESSION_CONTROL_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_GET_XTRA_T_SESSION_CONTROL_IND_V02. */
+
+   const qmiLocInjectWifiPositionIndMsgT_v02* pInjectWifiPositionInd;
+   /**< Response to the QMI_LOC_INJECT_WIFI_POSITION_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_INJECT_WIFI_POSITION_IND_V02. */
+
+   const qmiLocNotifyWifiStatusIndMsgT_v02* pNotifyWifiStatusInd;
+   /**< Response to the QMI_LOC_NOTIFY_WIFI_STATUS_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_NOTIFY_WIFI_STATUS_IND_V02. */
+
+   const qmiLocGetRegisteredEventsIndMsgT_v02* pGetRegisteredEventsInd;
+   /**< Response to the QMI_LOC_GET_REGISTERED_EVENTS_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_GET_REGISTERED_EVENTS_IND_V02. */
+
+   const qmiLocSetOperationModeIndMsgT_v02* pSetOperationModeInd;
+   /**< Response to the QMI_LOC_SET_OPERATION_MODE_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_SET_OPERATION_MODE_IND_V02. */
+
+   const qmiLocGetOperationModeIndMsgT_v02* pGetOperationModeInd;
+   /**< Response to the QMI_LOC_GET_OPERATION_MODE_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_GET_OPERATION_MODE_IND_V02. */
+
+   const qmiLocSetSpiStatusIndMsgT_v02* pSetSpiStatusInd;
+   /**< Response to the QMI_LOC_SET_SPI_STATUS_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_SET_SPI_STATUS_IND_V02. */
+
+   const qmiLocInjectSensorDataIndMsgT_v02* pInjectSensorDataInd;
+   /**< Response to the QMI_LOC_INJECT_SENSOR_DATA_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_INJECT_SENSOR_DATA_IND_V02. */
+
+   const qmiLocInjectTimeSyncDataIndMsgT_v02* pInjectTimeSyncDataInd;
+   /**< Response to the QMI_LOC_INJECT_TIME_SYNC_DATA_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_INJECT_TIME_SYNC_DATA_IND_V02. */
+
+   const qmiLocSetCradleMountConfigIndMsgT_v02* pSetCradleMountConfigInd;
+   /**< Response to the QMI_LOC_SET_CRADLE_MOUNT_CONFIG_IND_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_SET_CRADLE_MOUNT_CONFIG_REQ_V02. */
+
+   const qmiLocGetCradleMountConfigIndMsgT_v02* pGetCradleMountConfigInd;
+   /**< Response to the QMI_LOC_GET_CRADLE_MOUNT_CONFIG_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_GET_CRADLE_MOUNT_CONFIG_IND_V02. */
+
+   const qmiLocSetExternalPowerConfigIndMsgT_v02* pSetExternalPowerConfigInd;
+   /**< Response to the QMI_LOC_SET_EXTERNAL_POWER_CONFIG_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_SET_EXTERNAL_POWER_CONFIG_IND_V02. */
+
+   const qmiLocGetExternalPowerConfigIndMsgT_v02* pGetExternalPowerConfigInd;
+   /**< Response to the QMI_LOC_GET_EXTERNAL_POWER_CONFIG_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_GET_EXTERNAL_POWER_CONFIG_IND_V02. */
+
+   const qmiLocInformLocationServerConnStatusIndMsgT_v02*
+     pInformLocationServerConnStatusInd;
+   /**< Response to the QMI_LOC_INFORM_LOCATION_SERVER_CONN_STATUS_REQ_V02
+        request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_INFORM_LOCATION_SERVER_CONN_STATUS_IND_V02.*/
+
+   const qmiLocSetProtocolConfigParametersIndMsgT_v02*
+     pSetProtocolConfigParametersInd;
+   /**< Response to the QMI_LOC_SET_PROTOCOL_CONFIG_PARAMETERS_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_SET_PROTOCOL_CONFIG_PARAMETERS_IND_V02. */
+
+   const qmiLocGetProtocolConfigParametersIndMsgT_v02*
+     pGetProtocolConfigParametersInd;
+   /**< Response to the QMI_LOC_GET_PROTOCOL_CONFIG_PARAMETERS_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_GET_PROTOCOL_CONFIG_PARAMETERS_IND_V02. */
+
+   const qmiLocSetSensorControlConfigIndMsgT_v02* pSetSensorControlConfigInd;
+   /**< Response to the QMI_LOC_SET_SENSOR_CONTROL_CONFIG_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_SET_SENSOR_CONTROL_CONFIG_IND_V02.
+         */
+
+   const qmiLocGetSensorControlConfigIndMsgT_v02* pGetSensorControlConfigInd;
+   /**< Response to the QMI_LOC_GET_SENSOR_CONTROL_CONFIG_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_GET_SENSOR_CONTROL_CONFIG_IND_V02.
+         */
+
+   const qmiLocSetSensorPropertiesIndMsgT_v02* pSetSensorPropertiesInd;
+   /**< Response to the QMI_LOC_SET_SENSOR_PROPERTIES_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_SET_SENSOR_PROPERTIES_IND_V02.
+         */
+
+   const qmiLocGetSensorPropertiesIndMsgT_v02* pGetSensorPropertiesInd;
+   /**< Response to the QMI_LOC_GET_SENSOR_PROPERTIES_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_GET_SENSOR_PROPERTIES_IND_V02.
+         */
+
+   const qmiLocSetSensorPerformanceControlConfigIndMsgT_v02*
+     pSetSensorPerformanceControlConfigInd;
+   /**< Response to the
+        QMI_LOC_SET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_SET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_IND_V02. */
+
+   const qmiLocGetSensorPerformanceControlConfigIndMsgT_v02*
+     pGetSensorPerformanceControlConfigInd;
+   /**< Response to the
+        QMI_LOC_GET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_GET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_IND_V02. */
+
+   const qmiLocInjectSuplCertificateIndMsgT_v02* pInjectSuplCertificateInd;
+   /**< Response to the QMI_LOC_INJECT_SUPL_CERTIFICATE_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_INJECT_SUPL_CERTIFICATE_IND_V02. */
+
+   const qmiLocDeleteSuplCertificateIndMsgT_v02* pDeleteSuplCertificateInd;
+   /**< Response to the QMI_LOC_DELETE_SUPL_CERTIFICATE_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_DELETE_SUPL_CERTIFICATE_IND_V02. */
+
+   const qmiLocSetPositionEngineConfigParametersIndMsgT_v02*
+     pSetPositionEngineConfigParametersInd;
+   /**< Response to the QMI_LOC_SET_POSITION_ENGINE_CONFIG_PARAMETERS_REQ_V02
+        request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_SET_POSITION_ENGINE_CONFIG_PARAMETERS_IND_V02. */
+
+   const qmiLocGetPositionEngineConfigParametersIndMsgT_v02*
+     pGetPositionEngineConfigParametersInd;
+    /**< Response to the QMI_LOC_GET_POSITION_ENGINE_CONFIG_PARAMETERS_REQ_V02
+         request.
+
+         The respIndId field in the response indication callback is set to
+         QMI_LOC_GET_POSITION_ENGINE_CONFIG_PARAMETERS_IND_V02. */
+
+   const qmiLocAddCircularGeofenceIndMsgT_v02* pAddCircularGeofenceInd;
+   /**< Response to the QMI_LOC_ADD_CIRCULAR_GEOFENCE_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_ADD_CIRCULAR_GEOFENCE_IND_V02. */
+
+   const qmiLocDeleteGeofenceIndMsgT_v02* pDeleteGeofenceInd;
+   /**< Response to the QMI_LOC_DELETE_GEOFENCE_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_DELETE_GEOFENCE_IND_V02. */
+
+   const qmiLocQueryGeofenceIndMsgT_v02* pQueryGeofenceInd;
+    /**< Response to the QMI_LOC_QUERY_GEOFENCE_REQ_V02 request.
+
+         The respIndId field in the response indication callback is set to
+         QMI_LOC_QUERY_GEOFENCE_IND_V02. */
+
+   const qmiLocEditGeofenceIndMsgT_v02* pEditGeofenceInd;
+   /**< Response to the QMI_LOC_EDIT_GEOFENCE_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_EDIT_GEOFENCE_IND_V02. */
+
+   const qmiLocGetBestAvailablePositionIndMsgT_v02*
+      pGetBestAvailablePositionInd;
+   /**< Response to the QMI_LOC_GET_BEST_AVAILABLE_POSITION_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_GET_BEST_AVAILABLE_POSITION_IND_V02. */
+
+   const qmiLocSecureGetAvailablePositionIndMsgT_v02*
+      pSecureGetBestAvailablePositionInd;
+   /**< Response to the QMI_LOC_SECURE_GET_AVAILABLE_POSITION_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_SECURE_GET_AVAILABLE_POSITION_IND_V02. */
+
+   const qmiLocInjectMotionDataIndMsgT_v02* pInjectMotionDataInd;
+   /**< Response to the QMI_LOC_INJECT_MOTION_DATA_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_INJECT_MOTION_DATA_IND_V02. */
+
+   const qmiLocGetNiGeofenceIdListIndMsgT_v02* pGetNiGeofenceIdListInd;
+   /**< Response to the QMI_LOC_GET_NI_GEOFENCE_ID_LIST_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_GET_NI_GEOFENCE_ID_LIST_IND_V02. */
+
+   const qmiLocInjectGSMCellInfoIndMsgT_v02* pInjectGSMCellInfoInd;
+    /**< Response to the QMI_LOC_INJECT_GSM_CELL_INFO_REQ_V02 request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_INJECT_GSM_CELL_INFO_IND_V02. */
+
+   const qmiLocInjectNetworkInitiatedMessageIndMsgT_v02*
+     pInjectNetworkInitiatedMessageInd;
+
+   /**< Response to the QMI_LOC_INJECT_NETWORK_INITIATED_MESSAGE_REQ_V02
+        request.
+
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_INJECT_NETWORK_INITIATED_MESSAGE_IND_V02. */
+
+   const qmiLocWWANOutOfServiceNotificationIndMsgT_v02*
+     pWWANOutOfServiceNotificationInd;
+
+   /**< Response to the QMI_LOC_WWAN_OUT_OF_SERVICE_NOTIFICATION_REQ_V02
+        request.
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_WWAN_OUT_OF_SERVICE_NOTIFICATION_IND_V02. */
+
+   const qmiLocPedometerReportIndMsgT_v02* pPedometerReportInd;
+
+   /**< Response to the QMI_LOC_PEDOMETER_REPORT_REQ_V02 request.
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_PEDOMETER_REPORT_IND_V02. */
+
+    const qmiLocInjectWCDMACellInfoIndMsgT_v02 *pInjectWCDMACellInfoInd;
+    const qmiLocInjectTDSCDMACellInfoIndMsgT_v02 *pInjectTDSCDMACellInfoInd;
+    const qmiLocInjectSubscriberIDIndMsgT_v02 *pInjectSubscriberIDInd;
+    const qmiLocInjectWifiApDataIndMsgT_v02 *pInjectWifiApDataInd;
+    const qmiLocNotifyWifiAttachmentStatusIndMsgT_v02 *pNotifyWifiAttachmentStatusInd;
+    const qmiLocNotifyWifiEnabledStatusIndMsgT_v02 *pNotifyWifiEnabledStatusInd;
+
+    const qmiLocInjectVehicleSensorDataIndMsgT_v02 *pInjectVehicleSensorDataInd;
+
+    /**< Response to the QMI_LOC_INJECT_VEHICLE_SENSOR_DATA_REQ_V02 request.
+        The respIndId field in the response indication callback is set to
+        QMI_LOC_INJECT_VEHICLE_SENSOR_DATA_IND_V02. */
+
+    const qmiLocGetAvailWwanPositionIndMsgT_v02 *pGetAvailWwanPositionInd;
+    /*QMI_LOC_GET_AVAILABLE_WWAN_POSITION_IND_V02*/
+
+    const qmiLocSetXtraVersionCheckIndMsgT_v02 *pSetXtraVersionCheckInd;
+    /*QMI_LOC_SET_XTRA_VERSION_CHECK_IND_V02*/
+
+    const qmiLocSetGNSSConstRepConfigIndMsgT_v02 *pSetGNSSConstRepConfigInd;
+    /*QMI_LOC_SET_GNSS_CONSTELL_REPORT_CONFIG_IND_V02*/
+
+    const qmiLocStartDbtIndMsgT_v02 *pStartDbtInd;
+    /*QMI_LOC_START_DBT_IND_V02*/
+
+    const qmiLocStopDbtIndMsgT_v02 *pStopDbtInd;
+    /*QMI_LOC_STOP_DBT_IND_V02*/
+
+    const qmiLocInjectTimeZoneInfoIndMsgT_v02 *pInjectTimeZoneInfoInd;
+    /*QMI_LOC_INJECT_TIME_ZONE_INFO_IND_V02*/
+
+    const qmiLocQueryAonConfigIndMsgT_v02 *pQueryAonConfigInd;
+    /*QMI_LOC_QUERY_AON_CONFIG_IND_V02*/
+
+    const qmiLocGetSupportedFeatureIndMsgT_v02 *pGetSupportedFeatureInd;
+    /*QMI_LOC_GET_SUPPORTED_FEATURE_IND_V02*/
+
+    const qmiLocGtpApStatusIndMsgT_v02 *pGtpApStatusInd;
+    /*QMI_LOC_GTP_AP_STATUS_IND_V02*/
+
+    const qmiLocGdtDownloadBeginStatusIndMsgT_v02 *pGdtDownloadBeginStatusInd;
+    /*QMI_LOC_GDT_DOWNLOAD_BEGIN_STATUS_IND_V02*/
+
+    const qmiLocGdtDownloadReadyStatusIndMsgT_v02 *pGdtDownloadReadyStatusInd;
+    /*QMI_LOC_GDT_DOWNLOAD_READY_STATUS_IND_V02*/
+
+    const qmiLocGdtReceiveDoneStatusIndMsgT_v02 *pGdtReceiveDoneStatusInd;
+    /*QMI_LOC_GDT_RECEIVE_DONE_STATUS_IND_V02*/
+
+    const qmiLocGdtDownloadEndStatusIndMsgT_v02 *pGdtDownloadEndStatusInd;
+    /*QMI_LOC_GDT_DOWNLOAD_END_STATUS_IND_V02*/
+
+    const qmiLocDeleteGNSSServiceDataIndMsgT_v02 *pDeleteGNSSServiceDataInd;
+    /* QMI_LOC_DELETE_GNSS_SERVICE_DATA_REQ_V02*/
+}locClientRespIndUnionType;
+
+/** @} */ /* end_addtogroup data_types */
+
+/** @addtogroup callback_functions
+@{ */
+/**
+  Location event indication callback function type. The Location service can
+  generate two types of indications:
+
+  - Asynchronous events indications, such as time injection request and satellite
+    reports. The client specifies the asynchronous events it is interested in
+    receiving through the event mask (see locClientOpen()).
+  - Response indications that are generated as a response to a request. For
+    example, the QMI_LOC_GET_FIX_CRITERIA_REQ_V02 request generates the
+    indication, QMI_LOC_GET_FIX_CRITERIA_IND_V02.
+
+  This callback handles the asynchronous event indications.
+
+  @datatypes
+  #locClientHandleType \n
+  #locClientEventIndUnionType
+
+  @param handle            Location client for this event. Only the client who
+                           registered for the corresponding event receives
+                           this callback.
+  @param eventIndId        ID of the event indication.
+  @param eventIndPayload   Event indication payload.
+  @param pClientCookie     Pointer to the cookie the client specified during
+                           registration.
+
+  @return
+  None.
+
+  @dependencies
+  None. @newpage
+*/
+typedef void (*locClientEventIndCbType)(
+      locClientHandleType handle,
+      uint32_t eventIndId,
+      const locClientEventIndUnionType eventIndPayload,
+      void *pClientCookie
+);
+
+/**
+  Location response indication callback function type. The Location service can
+  generate two types of indications:
+
+  - Asynchronous events indications, such as time injection request and satellite
+    reports. The client specifies the asynchronous events it is interested in
+    receiving through the event mask (see locClientOpen()).
+  - Response indications that are generated as a response to a request. For
+    example, the QMI_LOC_GET_FIX_CRITERIA_REQ_V02 request generates the
+    indication, QMI_LOC_GET_FIX_CRITERIA_IND_V02.
+
+  This callback handles the response indications.
+
+  @datatypes
+  #locClientHandleType \n
+  #locClientRespIndUnionType
+
+  @param handle           Location client who sent the request for which this
+                          response indication is generated.
+  @param respIndId        ID of the response. It is the same value as the ID
+                          of request sent to the engine.
+  @param respIndPayload   Payload of the response indication.
+  @param pClientCookie    Pointer to the cookie the client specified during
+                          registration.
+
+  @return
+  None.
+
+  @dependencies
+  None. @newpage
+*/
+typedef void  (*locClientRespIndCbType)(
+      locClientHandleType handle,
+      uint32_t respIndId,
+      const locClientRespIndUnionType respIndPayload,
+      uint32_t respIndPayloadSize,
+      void *pClientCookie
+);
+
+/**
+  Location error callback function type. This function is called to inform
+  the client that the service is no longer available. When the client
+  receives this callback, it must close the existing connection and reopen
+  the client connection.
+
+  @datatypes
+  #locClientHandleType \n
+  #locClientErrorEnumType
+
+  @param handle           Location client who sent the request for which this
+                          error indication is generated.
+  @param errorId          Error ID.
+  @param pClientCookie    Payload associated with the error indication.
+
+  @return
+  None.
+
+  @dependencies
+  None.
+*/
+typedef void  (*locClientErrorCbType)(
+      locClientHandleType handle,
+      locClientErrorEnumType errorId,
+      void* pClientCookie
+ );
+/** @} */ /* end_addtogroup callback_functions */
+
+
+/** @ingroup data_types
+  Callback functions to be registered during locClientOpen().
+*/
+typedef struct
+{
+    uint32_t size;                       /**< Size of the structure. */
+    locClientEventIndCbType eventIndCb;  /**< Event indication callback. */
+    locClientRespIndCbType respIndCb;    /**< Response indication callback. */
+    locClientErrorCbType errorCb;        /**< Error indication callback.
+                                              @newpagetable */
+}locClientCallbacksType;
+
+/**
+  Response for getting qmi service list
+*/
+typedef struct
+{
+    qmi_get_supported_msgs_resp_v01 resp; /**< Response */
+}qmiLocGetSupportMsgT_v02;
+
+/*===========================================================================
+ *
+ *                          FUNCTION DECLARATION
+ *
+ *==========================================================================*/
+/** @addtogroup operation_functions
+@{ */
+/*==========================================================================
+    locClientOpen */
+/** @xreflabel{hdr:locClientOpenFunction}
+  Connects a location client to the location engine. If the connection is
+  successful, this function returns a handle that the location client uses for
+  future location operations.
+
+  @datatypes
+  #locClientStatusEnumType \n
+  #locClientEventMaskType \n
+  #locClientCallbacksType \n
+  #locClientHandleType
+
+  @param[in]  eventRegMask          Mask of asynchronous events the client is
+                                    interested in receiving.
+  @param[in]  pLocClientCallbacks   Pointer to structure containing the
+                                    callbacks.
+  @param[out] pLocClientHandle      Pointer to the handle to be used by the
+                                    client for any subsequent requests.
+  @param[in]  pLocClientCookie      Pointer to a cookie to be returned to the
+                                    client along with the callbacks.
+
+  @return
+  One of the following error codes:
+  - eLOC_CLIENT_SUCCESS -- If the connection is opened.
+  - Non-zero error code (see #locClientStatusEnumType) -- On failure.
+
+  @dependencies
+  None. @newpage
+*/
+extern locClientStatusEnumType locClientOpen (
+      locClientEventMaskType            eventRegMask,
+      const locClientCallbacksType*     pLocClientCallbacks,
+      locClientHandleType*              pLocClientHandle,
+      const void*                       pLocClientCookie
+);
+
+
+/*==========================================================================
+    locClientClose */
+/** @xreflabel{hdr:locClientCloseFunction}
+  Disconnects a client from the location engine and sets the handle to
+  LOC_CLIENT_INVALID_HANDLE_VALUE.
+
+  @datatypes
+  #locClientStatusEnumType \n
+  #locClientHandleType
+
+  @param[in] pLocClientHandle  Pointer to the handle returned by the
+                               locClientOpen() function.
+
+  @return
+  One of the following error codes:
+  - 0 (eLOC_CLIENT_SUCCESS) -- On success.
+  - Non-zero error code (see \ref locClientStatusEnumType) -- On failure.
+
+  @dependencies
+  None. @newpage
+*/
+extern locClientStatusEnumType locClientClose (
+      locClientHandleType* pLocClientHandle
+);
+
+/*=============================================================================
+    locClientSendReq */
+/** @xreflabel{hdr:locClientSendReqFunction}
+  Sends a message to the location engine. If this function is successful, the
+  client expects an indication (except start, stop, event registration, and
+  sensor injection messages) through the registered callback in the
+  locClientOpen() function.
+
+  The indication contains the status of the request. If the status is a success,
+  the indication also contains the payload associated with response.
+
+  @datatypes
+  #locClientStatusEnumType \n
+  #locClientHandleType \n
+  #locClientReqUnionType
+
+  @param[in] handle        Handle returned by the locClientOpen() function.
+  @param[in] reqId         QMI_LOC service message ID of the request.
+  @param[in] reqPayload    Payload of the request. This can be NULL if the
+                           request has no payload.
+
+  @return
+  One of the following error codes:
+  - 0 (eLOC_CLIENT_SUCCESS) -- On success.
+  - Non-zero error code (see \ref locClientStatusEnumType) -- On failure.
+
+  @dependencies
+  None. @newpage
+*/
+extern locClientStatusEnumType locClientSendReq(
+     locClientHandleType       handle,
+     uint32_t                  reqId,
+     locClientReqUnionType     reqPayload
+);
+
+/*=============================================================================
+    locClientSupportMsgCheck */
+/**
+  @brief Sends a QMI_LOC_GET_SUPPORTED_MSGS_REQ_V02 message to the
+         location engine, and then receives a list of all services supported
+         by the engine. This function will check if the input service(s) form
+         the client is in the list or not. If the locClientSupportMsgCheck()
+         function is successful, the client should expect an result of
+         the service is supported or not recorded in supportedMsg.
+  @param [in] handle Handle returned by the locClientOpen()
+              function.
+  @param [in] supportedMsg   a integer used to record which
+                             message is supported
+
+  @return
+  One of the following error codes:
+  - 0 (eLOC_CLIENT_SUCCESS) -- On success.
+  - Non-zero error code (see \ref locClientStatusEnumType) -- On failure.
+
+  @dependencies
+  None. @newpage
+*/
+extern locClientStatusEnumType locClientSupportMsgCheck(
+     locClientHandleType      handle,
+     const uint32_t*          msgArray,
+     uint32_t                 msgArrayLength,
+     uint64_t*                supportedMsg
+);
+
+/*=============================================================================
+    locClientGetSizeByEventIndId */
+/** Gets the size of the event indication structure from a specified ID.
+
+  @param[in]  eventIndId      Event indicator ID.
+  @param[out] pEventIndSize   Pointer to the size of the structure.
+
+  @return
+  TRUE -- The event ID was found. \n
+  FALSE -- Otherwise.
+
+  @dependencies
+  None. @newpage
+*/
+extern bool locClientGetSizeByEventIndId(
+  uint32_t eventIndId,
+  size_t *pEventIndSize);
+
+
+/*=============================================================================
+    locClientGetSizeByRespIndId */
+/** Gets the size of the response indication structure from a specified ID.
+
+  @param[in]  respIndId      Response indicator ID.
+  @param[out] pRespIndSize   Pointer to the size of the structure.
+
+  @return
+  TRUE -- The response ID was found. \n
+  FALSE -- Otherwise.
+
+  @dependencies
+  None.
+*/
+extern bool locClientGetSizeByRespIndId(
+  uint32_t respIndId,
+  size_t *pRespIndSize);
+
+/** locClientRegisterEventMask
+ *  @brief registers the event mask with loc service
+ *  @param [in] clientHandle
+ *  @param [in] eventRegMask
+ *  @return true if indication was validated; else false */
+
+extern bool locClientRegisterEventMask(
+    locClientHandleType clientHandle,
+    locClientEventMaskType eventRegMask);
+
+/*=============================================================================*/
+/** @} */ /* end_addtogroup operation_functions */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LOC_API_V02_CLIENT_H*/
diff --git a/gps/loc_api/loc_api_v02/loc_api_v02_log.c b/gps/loc_api/loc_api_v02/loc_api_v02_log.c
new file mode 100644
index 0000000..763470c
--- /dev/null
+++ b/gps/loc_api/loc_api_v02/loc_api_v02_log.c
@@ -0,0 +1,401 @@
+/* Copyright (c) 2011-2015, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of The Linux Foundation, nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#include <loc_api_v02_log.h>
+#include <location_service_v02.h>
+
+static const loc_name_val_s_type loc_v02_event_name[] =
+{
+    NAME_VAL(QMI_LOC_INFORM_CLIENT_REVISION_REQ_V02),
+    NAME_VAL(QMI_LOC_INFORM_CLIENT_REVISION_RESP_V02),
+    NAME_VAL(QMI_LOC_REG_EVENTS_REQ_V02),
+    NAME_VAL(QMI_LOC_REG_EVENTS_RESP_V02),
+    NAME_VAL(QMI_LOC_START_REQ_V02),
+    NAME_VAL(QMI_LOC_START_RESP_V02),
+    NAME_VAL(QMI_LOC_STOP_REQ_V02),
+    NAME_VAL(QMI_LOC_STOP_RESP_V02),
+    NAME_VAL(QMI_LOC_EVENT_POSITION_REPORT_IND_V02),
+    NAME_VAL(QMI_LOC_EVENT_GNSS_SV_INFO_IND_V02),
+    NAME_VAL(QMI_LOC_EVENT_NMEA_IND_V02),
+    NAME_VAL(QMI_LOC_EVENT_NI_NOTIFY_VERIFY_REQ_IND_V02),
+    NAME_VAL(QMI_LOC_EVENT_INJECT_TIME_REQ_IND_V02),
+    NAME_VAL(QMI_LOC_EVENT_INJECT_PREDICTED_ORBITS_REQ_IND_V02),
+    NAME_VAL(QMI_LOC_EVENT_INJECT_POSITION_REQ_IND_V02),
+    NAME_VAL(QMI_LOC_EVENT_ENGINE_STATE_IND_V02),
+    NAME_VAL(QMI_LOC_EVENT_FIX_SESSION_STATE_IND_V02),
+    NAME_VAL(QMI_LOC_EVENT_WIFI_REQ_IND_V02),
+    NAME_VAL(QMI_LOC_EVENT_SENSOR_STREAMING_READY_STATUS_IND_V02),
+    NAME_VAL(QMI_LOC_EVENT_TIME_SYNC_REQ_IND_V02),
+    NAME_VAL(QMI_LOC_EVENT_SET_SPI_STREAMING_REPORT_IND_V02),
+    NAME_VAL(QMI_LOC_EVENT_LOCATION_SERVER_CONNECTION_REQ_IND_V02),
+    NAME_VAL(QMI_LOC_EVENT_INJECT_WIFI_AP_DATA_REQ_IND_V02),
+    NAME_VAL(QMI_LOC_GET_SERVICE_REVISION_REQ_V02),
+    NAME_VAL(QMI_LOC_GET_SERVICE_REVISION_RESP_V02),
+    NAME_VAL(QMI_LOC_GET_SERVICE_REVISION_IND_V02),
+    NAME_VAL(QMI_LOC_GET_FIX_CRITERIA_REQ_V02),
+    NAME_VAL(QMI_LOC_GET_FIX_CRITERIA_RESP_V02),
+    NAME_VAL(QMI_LOC_GET_FIX_CRITERIA_IND_V02),
+    NAME_VAL(QMI_LOC_NI_USER_RESPONSE_REQ_V02),
+    NAME_VAL(QMI_LOC_NI_USER_RESPONSE_RESP_V02),
+    NAME_VAL(QMI_LOC_NI_USER_RESPONSE_IND_V02),
+    NAME_VAL(QMI_LOC_INJECT_PREDICTED_ORBITS_DATA_REQ_V02),
+    NAME_VAL(QMI_LOC_INJECT_PREDICTED_ORBITS_DATA_RESP_V02),
+    NAME_VAL(QMI_LOC_INJECT_PREDICTED_ORBITS_DATA_IND_V02),
+    NAME_VAL(QMI_LOC_GET_PREDICTED_ORBITS_DATA_SOURCE_REQ_V02),
+    NAME_VAL(QMI_LOC_GET_PREDICTED_ORBITS_DATA_SOURCE_RESP_V02),
+    NAME_VAL(QMI_LOC_GET_PREDICTED_ORBITS_DATA_SOURCE_IND_V02),
+    NAME_VAL(QMI_LOC_GET_PREDICTED_ORBITS_DATA_VALIDITY_REQ_V02),
+    NAME_VAL(QMI_LOC_GET_PREDICTED_ORBITS_DATA_VALIDITY_RESP_V02),
+    NAME_VAL(QMI_LOC_GET_PREDICTED_ORBITS_DATA_VALIDITY_IND_V02),
+    NAME_VAL(QMI_LOC_INJECT_UTC_TIME_REQ_V02),
+    NAME_VAL(QMI_LOC_INJECT_UTC_TIME_RESP_V02),
+    NAME_VAL(QMI_LOC_INJECT_UTC_TIME_IND_V02),
+    NAME_VAL(QMI_LOC_INJECT_POSITION_REQ_V02),
+    NAME_VAL(QMI_LOC_INJECT_POSITION_RESP_V02),
+    NAME_VAL(QMI_LOC_INJECT_POSITION_IND_V02),
+    NAME_VAL(QMI_LOC_SET_ENGINE_LOCK_REQ_V02),
+    NAME_VAL(QMI_LOC_SET_ENGINE_LOCK_RESP_V02),
+    NAME_VAL(QMI_LOC_SET_ENGINE_LOCK_IND_V02),
+    NAME_VAL(QMI_LOC_GET_ENGINE_LOCK_REQ_V02),
+    NAME_VAL(QMI_LOC_GET_ENGINE_LOCK_RESP_V02),
+    NAME_VAL(QMI_LOC_GET_ENGINE_LOCK_IND_V02),
+    NAME_VAL(QMI_LOC_SET_SBAS_CONFIG_REQ_V02),
+    NAME_VAL(QMI_LOC_SET_SBAS_CONFIG_RESP_V02),
+    NAME_VAL(QMI_LOC_SET_SBAS_CONFIG_IND_V02),
+    NAME_VAL(QMI_LOC_GET_SBAS_CONFIG_REQ_V02),
+    NAME_VAL(QMI_LOC_GET_SBAS_CONFIG_RESP_V02),
+    NAME_VAL(QMI_LOC_GET_SBAS_CONFIG_IND_V02),
+    NAME_VAL(QMI_LOC_SET_NMEA_TYPES_REQ_V02),
+    NAME_VAL(QMI_LOC_SET_NMEA_TYPES_RESP_V02),
+    NAME_VAL(QMI_LOC_SET_NMEA_TYPES_IND_V02),
+    NAME_VAL(QMI_LOC_GET_NMEA_TYPES_REQ_V02),
+    NAME_VAL(QMI_LOC_GET_NMEA_TYPES_RESP_V02),
+    NAME_VAL(QMI_LOC_GET_NMEA_TYPES_IND_V02),
+    NAME_VAL(QMI_LOC_SET_LOW_POWER_MODE_REQ_V02),
+    NAME_VAL(QMI_LOC_SET_LOW_POWER_MODE_RESP_V02),
+    NAME_VAL(QMI_LOC_SET_LOW_POWER_MODE_IND_V02),
+    NAME_VAL(QMI_LOC_GET_LOW_POWER_MODE_REQ_V02),
+    NAME_VAL(QMI_LOC_GET_LOW_POWER_MODE_RESP_V02),
+    NAME_VAL(QMI_LOC_GET_LOW_POWER_MODE_IND_V02),
+    NAME_VAL(QMI_LOC_SET_SERVER_REQ_V02),
+    NAME_VAL(QMI_LOC_SET_SERVER_RESP_V02),
+    NAME_VAL(QMI_LOC_SET_SERVER_IND_V02),
+    NAME_VAL(QMI_LOC_GET_SERVER_REQ_V02),
+    NAME_VAL(QMI_LOC_GET_SERVER_RESP_V02),
+    NAME_VAL(QMI_LOC_GET_SERVER_IND_V02),
+    NAME_VAL(QMI_LOC_DELETE_ASSIST_DATA_REQ_V02),
+    NAME_VAL(QMI_LOC_DELETE_ASSIST_DATA_RESP_V02),
+    NAME_VAL(QMI_LOC_DELETE_ASSIST_DATA_IND_V02),
+    NAME_VAL(QMI_LOC_SET_XTRA_T_SESSION_CONTROL_REQ_V02),
+    NAME_VAL(QMI_LOC_SET_XTRA_T_SESSION_CONTROL_RESP_V02),
+    NAME_VAL(QMI_LOC_SET_XTRA_T_SESSION_CONTROL_IND_V02),
+    NAME_VAL(QMI_LOC_GET_XTRA_T_SESSION_CONTROL_REQ_V02),
+    NAME_VAL(QMI_LOC_GET_XTRA_T_SESSION_CONTROL_RESP_V02),
+    NAME_VAL(QMI_LOC_GET_XTRA_T_SESSION_CONTROL_IND_V02),
+    NAME_VAL(QMI_LOC_INJECT_WIFI_POSITION_REQ_V02),
+    NAME_VAL(QMI_LOC_INJECT_WIFI_POSITION_RESP_V02),
+    NAME_VAL(QMI_LOC_INJECT_WIFI_POSITION_IND_V02),
+    NAME_VAL(QMI_LOC_NOTIFY_WIFI_STATUS_REQ_V02),
+    NAME_VAL(QMI_LOC_NOTIFY_WIFI_STATUS_RESP_V02),
+    NAME_VAL(QMI_LOC_NOTIFY_WIFI_STATUS_IND_V02),
+    NAME_VAL(QMI_LOC_GET_REGISTERED_EVENTS_REQ_V02),
+    NAME_VAL(QMI_LOC_GET_REGISTERED_EVENTS_RESP_V02),
+    NAME_VAL(QMI_LOC_GET_REGISTERED_EVENTS_IND_V02),
+    NAME_VAL(QMI_LOC_SET_OPERATION_MODE_REQ_V02),
+    NAME_VAL(QMI_LOC_SET_OPERATION_MODE_RESP_V02),
+    NAME_VAL(QMI_LOC_SET_OPERATION_MODE_IND_V02),
+    NAME_VAL(QMI_LOC_GET_OPERATION_MODE_REQ_V02),
+    NAME_VAL(QMI_LOC_GET_OPERATION_MODE_RESP_V02),
+    NAME_VAL(QMI_LOC_GET_OPERATION_MODE_IND_V02),
+    NAME_VAL(QMI_LOC_SET_SPI_STATUS_REQ_V02),
+    NAME_VAL(QMI_LOC_SET_SPI_STATUS_RESP_V02),
+    NAME_VAL(QMI_LOC_SET_SPI_STATUS_IND_V02),
+    NAME_VAL(QMI_LOC_INJECT_SENSOR_DATA_REQ_V02),
+    NAME_VAL(QMI_LOC_INJECT_SENSOR_DATA_RESP_V02),
+    NAME_VAL(QMI_LOC_INJECT_SENSOR_DATA_IND_V02),
+    NAME_VAL(QMI_LOC_INJECT_TIME_SYNC_DATA_REQ_V02),
+    NAME_VAL(QMI_LOC_INJECT_TIME_SYNC_DATA_RESP_V02),
+    NAME_VAL(QMI_LOC_INJECT_TIME_SYNC_DATA_IND_V02),
+    NAME_VAL(QMI_LOC_SET_CRADLE_MOUNT_CONFIG_REQ_V02),
+    NAME_VAL(QMI_LOC_SET_CRADLE_MOUNT_CONFIG_RESP_V02),
+    NAME_VAL(QMI_LOC_SET_CRADLE_MOUNT_CONFIG_IND_V02),
+    NAME_VAL(QMI_LOC_GET_CRADLE_MOUNT_CONFIG_REQ_V02),
+    NAME_VAL(QMI_LOC_GET_CRADLE_MOUNT_CONFIG_RESP_V02),
+    NAME_VAL(QMI_LOC_GET_CRADLE_MOUNT_CONFIG_IND_V02),
+    NAME_VAL(QMI_LOC_SET_EXTERNAL_POWER_CONFIG_REQ_V02),
+    NAME_VAL(QMI_LOC_SET_EXTERNAL_POWER_CONFIG_RESP_V02),
+    NAME_VAL(QMI_LOC_SET_EXTERNAL_POWER_CONFIG_IND_V02),
+    NAME_VAL(QMI_LOC_GET_EXTERNAL_POWER_CONFIG_REQ_V02),
+    NAME_VAL(QMI_LOC_GET_EXTERNAL_POWER_CONFIG_RESP_V02),
+    NAME_VAL(QMI_LOC_GET_EXTERNAL_POWER_CONFIG_IND_V02),
+    NAME_VAL(QMI_LOC_INFORM_LOCATION_SERVER_CONN_STATUS_REQ_V02),
+    NAME_VAL(QMI_LOC_INFORM_LOCATION_SERVER_CONN_STATUS_RESP_V02),
+    NAME_VAL(QMI_LOC_INFORM_LOCATION_SERVER_CONN_STATUS_IND_V02),
+    NAME_VAL(QMI_LOC_SET_PROTOCOL_CONFIG_PARAMETERS_REQ_V02),
+    NAME_VAL(QMI_LOC_SET_PROTOCOL_CONFIG_PARAMETERS_RESP_V02),
+    NAME_VAL(QMI_LOC_SET_PROTOCOL_CONFIG_PARAMETERS_IND_V02),
+    NAME_VAL(QMI_LOC_GET_PROTOCOL_CONFIG_PARAMETERS_REQ_V02),
+    NAME_VAL(QMI_LOC_GET_PROTOCOL_CONFIG_PARAMETERS_RESP_V02),
+    NAME_VAL(QMI_LOC_GET_PROTOCOL_CONFIG_PARAMETERS_IND_V02),
+    NAME_VAL(QMI_LOC_SET_SENSOR_CONTROL_CONFIG_REQ_V02),
+    NAME_VAL(QMI_LOC_SET_SENSOR_CONTROL_CONFIG_RESP_V02),
+    NAME_VAL(QMI_LOC_SET_SENSOR_CONTROL_CONFIG_IND_V02),
+    NAME_VAL(QMI_LOC_GET_SENSOR_CONTROL_CONFIG_REQ_V02),
+    NAME_VAL(QMI_LOC_GET_SENSOR_CONTROL_CONFIG_RESP_V02),
+    NAME_VAL(QMI_LOC_GET_SENSOR_CONTROL_CONFIG_IND_V02),
+    NAME_VAL(QMI_LOC_SET_SENSOR_PROPERTIES_REQ_V02),
+    NAME_VAL(QMI_LOC_SET_SENSOR_PROPERTIES_RESP_V02),
+    NAME_VAL(QMI_LOC_SET_SENSOR_PROPERTIES_IND_V02),
+    NAME_VAL(QMI_LOC_GET_SENSOR_PROPERTIES_REQ_V02),
+    NAME_VAL(QMI_LOC_GET_SENSOR_PROPERTIES_RESP_V02),
+    NAME_VAL(QMI_LOC_GET_SENSOR_PROPERTIES_IND_V02),
+    NAME_VAL(QMI_LOC_SET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_REQ_V02),
+    NAME_VAL(QMI_LOC_SET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_RESP_V02),
+    NAME_VAL(QMI_LOC_SET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_IND_V02),
+    NAME_VAL(QMI_LOC_GET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_REQ_V02),
+    NAME_VAL(QMI_LOC_GET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_RESP_V02),
+    NAME_VAL(QMI_LOC_GET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_IND_V02),
+    NAME_VAL(QMI_LOC_INJECT_SUPL_CERTIFICATE_REQ_V02),
+    NAME_VAL(QMI_LOC_INJECT_SUPL_CERTIFICATE_RESP_V02),
+    NAME_VAL(QMI_LOC_INJECT_SUPL_CERTIFICATE_IND_V02),
+    NAME_VAL(QMI_LOC_DELETE_SUPL_CERTIFICATE_REQ_V02),
+    NAME_VAL(QMI_LOC_DELETE_SUPL_CERTIFICATE_RESP_V02),
+    NAME_VAL(QMI_LOC_DELETE_SUPL_CERTIFICATE_IND_V02),
+    NAME_VAL(QMI_LOC_SET_POSITION_ENGINE_CONFIG_PARAMETERS_REQ_V02),
+    NAME_VAL(QMI_LOC_SET_POSITION_ENGINE_CONFIG_PARAMETERS_RESP_V02),
+    NAME_VAL(QMI_LOC_SET_POSITION_ENGINE_CONFIG_PARAMETERS_IND_V02),
+    NAME_VAL(QMI_LOC_GET_POSITION_ENGINE_CONFIG_PARAMETERS_REQ_V02),
+    NAME_VAL(QMI_LOC_GET_POSITION_ENGINE_CONFIG_PARAMETERS_RESP_V02),
+    NAME_VAL(QMI_LOC_GET_POSITION_ENGINE_CONFIG_PARAMETERS_IND_V02),
+    NAME_VAL(QMI_LOC_EVENT_NI_GEOFENCE_NOTIFICATION_IND_V02),
+    NAME_VAL(QMI_LOC_EVENT_GEOFENCE_GEN_ALERT_IND_V02),
+    NAME_VAL(QMI_LOC_EVENT_GEOFENCE_BREACH_NOTIFICATION_IND_V02),
+    NAME_VAL(QMI_LOC_EVENT_GEOFENCE_BATCHED_BREACH_NOTIFICATION_IND_V02),
+    NAME_VAL(QMI_LOC_ADD_CIRCULAR_GEOFENCE_REQ_V02),
+    NAME_VAL(QMI_LOC_ADD_CIRCULAR_GEOFENCE_RESP_V02),
+    NAME_VAL(QMI_LOC_ADD_CIRCULAR_GEOFENCE_IND_V02),
+    NAME_VAL(QMI_LOC_DELETE_GEOFENCE_REQ_V02),
+    NAME_VAL(QMI_LOC_DELETE_GEOFENCE_RESP_V02),
+    NAME_VAL(QMI_LOC_DELETE_GEOFENCE_IND_V02),
+    NAME_VAL(QMI_LOC_QUERY_GEOFENCE_REQ_V02),
+    NAME_VAL(QMI_LOC_QUERY_GEOFENCE_RESP_V02),
+    NAME_VAL(QMI_LOC_QUERY_GEOFENCE_IND_V02),
+    NAME_VAL(QMI_LOC_EDIT_GEOFENCE_REQ_V02),
+    NAME_VAL(QMI_LOC_EDIT_GEOFENCE_RESP_V02),
+    NAME_VAL(QMI_LOC_EDIT_GEOFENCE_IND_V02),
+    NAME_VAL(QMI_LOC_GET_BEST_AVAILABLE_POSITION_REQ_V02),
+    NAME_VAL(QMI_LOC_GET_BEST_AVAILABLE_POSITION_RESP_V02),
+    NAME_VAL(QMI_LOC_GET_BEST_AVAILABLE_POSITION_IND_V02),
+    NAME_VAL(QMI_LOC_INJECT_MOTION_DATA_REQ_V02),
+    NAME_VAL(QMI_LOC_INJECT_MOTION_DATA_RESP_V02),
+    NAME_VAL(QMI_LOC_INJECT_MOTION_DATA_IND_V02),
+    NAME_VAL(QMI_LOC_GET_NI_GEOFENCE_ID_LIST_REQ_V02),
+    NAME_VAL(QMI_LOC_GET_NI_GEOFENCE_ID_LIST_RESP_V02),
+    NAME_VAL(QMI_LOC_GET_NI_GEOFENCE_ID_LIST_IND_V02),
+    NAME_VAL(QMI_LOC_INJECT_GSM_CELL_INFO_REQ_V02),
+    NAME_VAL(QMI_LOC_INJECT_GSM_CELL_INFO_RESP_V02),
+    NAME_VAL(QMI_LOC_INJECT_GSM_CELL_INFO_IND_V02),
+    NAME_VAL(QMI_LOC_INJECT_NETWORK_INITIATED_MESSAGE_REQ_V02),
+    NAME_VAL(QMI_LOC_INJECT_NETWORK_INITIATED_MESSAGE_RESP_V02),
+    NAME_VAL(QMI_LOC_INJECT_NETWORK_INITIATED_MESSAGE_IND_V02),
+    NAME_VAL(QMI_LOC_WWAN_OUT_OF_SERVICE_NOTIFICATION_REQ_V02),
+    NAME_VAL(QMI_LOC_WWAN_OUT_OF_SERVICE_NOTIFICATION_RESP_V02),
+    NAME_VAL(QMI_LOC_WWAN_OUT_OF_SERVICE_NOTIFICATION_IND_V02),
+    NAME_VAL(QMI_LOC_EVENT_PEDOMETER_CONTROL_IND_V02),
+    NAME_VAL(QMI_LOC_EVENT_MOTION_DATA_CONTROL_IND_V02),
+    NAME_VAL(QMI_LOC_PEDOMETER_REPORT_REQ_V02),
+    NAME_VAL(QMI_LOC_PEDOMETER_REPORT_RESP_V02),
+    NAME_VAL(QMI_LOC_PEDOMETER_REPORT_IND_V02),
+    NAME_VAL(QMI_LOC_INJECT_WCDMA_CELL_INFO_REQ_V02),
+    NAME_VAL(QMI_LOC_INJECT_WCDMA_CELL_INFO_RESP_V02),
+    NAME_VAL(QMI_LOC_INJECT_WCDMA_CELL_INFO_IND_V02),
+    NAME_VAL(QMI_LOC_INJECT_TDSCDMA_CELL_INFO_REQ_V02),
+    NAME_VAL(QMI_LOC_INJECT_TDSCDMA_CELL_INFO_RESP_V02),
+    NAME_VAL(QMI_LOC_INJECT_TDSCDMA_CELL_INFO_IND_V02),
+    NAME_VAL(QMI_LOC_INJECT_SUBSCRIBER_ID_REQ_V02),
+    NAME_VAL(QMI_LOC_INJECT_SUBSCRIBER_ID_RESP_V02),
+    NAME_VAL(QMI_LOC_INJECT_SUBSCRIBER_ID_IND_V02),
+    NAME_VAL(QMI_LOC_GET_SUPPORTED_MSGS_REQ_V02),
+    NAME_VAL(QMI_LOC_GET_SUPPORTED_MSGS_RESP_V02),
+    NAME_VAL(QMI_LOC_GET_SUPPORTED_FIELDS_REQ_V02),
+    NAME_VAL(QMI_LOC_GET_SUPPORTED_FIELDS_RESP_V02),
+    NAME_VAL(QMI_LOC_INJECT_WIFI_AP_DATA_REQ_V02),
+    NAME_VAL(QMI_LOC_INJECT_WIFI_AP_DATA_RESP_V02),
+    NAME_VAL(QMI_LOC_INJECT_WIFI_AP_DATA_IND_V02),
+    NAME_VAL(QMI_LOC_GET_BATCH_SIZE_REQ_V02),
+    NAME_VAL(QMI_LOC_GET_BATCH_SIZE_RESP_V02),
+    NAME_VAL(QMI_LOC_GET_BATCH_SIZE_IND_V02),
+    NAME_VAL(QMI_LOC_START_BATCHING_REQ_V02),
+    NAME_VAL(QMI_LOC_START_BATCHING_RESP_V02),
+    NAME_VAL(QMI_LOC_START_BATCHING_IND_V02),
+    NAME_VAL(QMI_LOC_EVENT_BATCH_FULL_NOTIFICATION_IND_V02),
+    NAME_VAL(QMI_LOC_READ_FROM_BATCH_REQ_V02),
+    NAME_VAL(QMI_LOC_READ_FROM_BATCH_RESP_V02),
+    NAME_VAL(QMI_LOC_READ_FROM_BATCH_IND_V02),
+    NAME_VAL(QMI_LOC_STOP_BATCHING_REQ_V02),
+    NAME_VAL(QMI_LOC_STOP_BATCHING_RESP_V02),
+    NAME_VAL(QMI_LOC_STOP_BATCHING_IND_V02),
+    NAME_VAL(QMI_LOC_RELEASE_BATCH_REQ_V02),
+    NAME_VAL(QMI_LOC_RELEASE_BATCH_RESP_V02),
+    NAME_VAL(QMI_LOC_RELEASE_BATCH_IND_V02),
+    NAME_VAL(QMI_LOC_INJECT_VEHICLE_SENSOR_DATA_REQ_V02),
+    NAME_VAL(QMI_LOC_INJECT_VEHICLE_SENSOR_DATA_RESP_V02),
+    NAME_VAL(QMI_LOC_INJECT_VEHICLE_SENSOR_DATA_IND_V02),
+    NAME_VAL(QMI_LOC_NOTIFY_WIFI_ATTACHMENT_STATUS_REQ_V02),
+    NAME_VAL(QMI_LOC_NOTIFY_WIFI_ATTACHMENT_STATUS_RESP_V02),
+    NAME_VAL(QMI_LOC_NOTIFY_WIFI_ATTACHMENT_STATUS_IND_V02),
+    NAME_VAL(QMI_LOC_NOTIFY_WIFI_ENABLED_STATUS_REQ_V02),
+    NAME_VAL(QMI_LOC_NOTIFY_WIFI_ENABLED_STATUS_RESP_V02),
+    NAME_VAL(QMI_LOC_NOTIFY_WIFI_ENABLED_STATUS_IND_V02),
+    NAME_VAL(QMI_LOC_SET_PREMIUM_SERVICES_CONFIG_REQ_V02),
+    NAME_VAL(QMI_LOC_SET_PREMIUM_SERVICES_CONFIG_RESP_V02),
+    NAME_VAL(QMI_LOC_SET_PREMIUM_SERVICES_CONFIG_IND_V02),
+    NAME_VAL(QMI_LOC_GET_AVAILABLE_WWAN_POSITION_REQ_V02),
+    NAME_VAL(QMI_LOC_GET_AVAILABLE_WWAN_POSITION_RESP_V02),
+    NAME_VAL(QMI_LOC_GET_AVAILABLE_WWAN_POSITION_IND_V02),
+    NAME_VAL(QMI_LOC_SET_XTRA_VERSION_CHECK_REQ_V02),
+    NAME_VAL(QMI_LOC_SET_XTRA_VERSION_CHECK_RESP_V02),
+    NAME_VAL(QMI_LOC_SET_XTRA_VERSION_CHECK_IND_V02),
+    NAME_VAL(QMI_LOC_EVENT_GEOFENCE_PROXIMITY_NOTIFICATION_IND_V02),
+    NAME_VAL(QMI_LOC_INJECT_GTP_CLIENT_DOWNLOADED_DATA_REQ_V02),
+    NAME_VAL(QMI_LOC_INJECT_GTP_CLIENT_DOWNLOADED_DATA_RESP_V02),
+    NAME_VAL(QMI_LOC_INJECT_GTP_CLIENT_DOWNLOADED_DATA_IND_V02),
+    NAME_VAL(QMI_LOC_GDT_UPLOAD_BEGIN_STATUS_REQ_V02),
+    NAME_VAL(QMI_LOC_GDT_UPLOAD_BEGIN_STATUS_RESP_V02),
+    NAME_VAL(QMI_LOC_GDT_UPLOAD_BEGIN_STATUS_IND_V02),
+    NAME_VAL(QMI_LOC_GDT_UPLOAD_END_REQ_V02),
+    NAME_VAL(QMI_LOC_GDT_UPLOAD_END_RESP_V02),
+    NAME_VAL(QMI_LOC_GDT_UPLOAD_END_IND_V02),
+    NAME_VAL(QMI_LOC_EVENT_GDT_UPLOAD_BEGIN_STATUS_REQ_IND_V02),
+    NAME_VAL(QMI_LOC_EVENT_GDT_UPLOAD_END_REQ_IND_V02),
+    NAME_VAL(QMI_LOC_EVENT_GNSS_MEASUREMENT_REPORT_IND_V02),
+    NAME_VAL(QMI_LOC_SET_GNSS_CONSTELL_REPORT_CONFIG_V02),
+    NAME_VAL(QMI_LOC_SET_GNSS_CONSTELL_REPORT_CONFIG_RESP_V02),
+    NAME_VAL(QMI_LOC_SET_GNSS_CONSTELL_REPORT_CONFIG_IND_V02),
+    NAME_VAL(QMI_LOC_START_DBT_REQ_V02),
+    NAME_VAL(QMI_LOC_START_DBT_RESP_V02),
+    NAME_VAL(QMI_LOC_START_DBT_IND_V02),
+    NAME_VAL(QMI_LOC_STOP_DBT_REQ_V02),
+    NAME_VAL(QMI_LOC_STOP_DBT_RESP_V02),
+    NAME_VAL(QMI_LOC_STOP_DBT_IND_V02),
+    NAME_VAL(QMI_LOC_EVENT_DBT_POSITION_REPORT_IND_V02),
+    NAME_VAL(QMI_LOC_EVENT_DBT_SESSION_STATUS_IND_V02),
+    NAME_VAL(QMI_LOC_SECURE_GET_AVAILABLE_POSITION_IND_V02),
+    NAME_VAL(QMI_LOC_EVENT_GEOFENCE_BATCHED_DWELL_NOTIFICATION_IND_V02),
+    NAME_VAL(QMI_LOC_EVENT_GET_TIME_ZONE_INFO_IND_V02),
+    NAME_VAL(QMI_LOC_INJECT_TIME_ZONE_INFO_REQ_V02),
+    NAME_VAL(QMI_LOC_INJECT_TIME_ZONE_INFO_RESP_V02),
+    NAME_VAL(QMI_LOC_INJECT_TIME_ZONE_INFO_IND_V02),
+    NAME_VAL(QMI_LOC_INJECT_APCACHE_DATA_REQ_V02),
+    NAME_VAL(QMI_LOC_INJECT_APCACHE_DATA_RESP_V02),
+    NAME_VAL(QMI_LOC_INJECT_APCACHE_DATA_IND_V02),
+    NAME_VAL(QMI_LOC_INJECT_APDONOTCACHE_DATA_REQ_V02),
+    NAME_VAL(QMI_LOC_INJECT_APDONOTCACHE_DATA_RESP_V02),
+    NAME_VAL(QMI_LOC_INJECT_APDONOTCACHE_DATA_IND_V02),
+    NAME_VAL(QMI_LOC_EVENT_BATCHING_STATUS_IND_V02),
+    NAME_VAL(QMI_LOC_QUERY_AON_CONFIG_REQ_V02),
+    NAME_VAL(QMI_LOC_QUERY_AON_CONFIG_RESP_V02),
+    NAME_VAL(QMI_LOC_QUERY_AON_CONFIG_IND_V02),
+    NAME_VAL(QMI_LOC_GTP_AP_STATUS_REQ_V02),
+    NAME_VAL(QMI_LOC_GTP_AP_STATUS_RESP_V02),
+    NAME_VAL(QMI_LOC_GTP_AP_STATUS_IND_V02),
+    NAME_VAL(QMI_LOC_GDT_DOWNLOAD_BEGIN_STATUS_REQ_V02),
+    NAME_VAL(QMI_LOC_GDT_DOWNLOAD_BEGIN_STATUS_RESP_V02),
+    NAME_VAL(QMI_LOC_GDT_DOWNLOAD_BEGIN_STATUS_IND_V02),
+    NAME_VAL(QMI_LOC_GDT_DOWNLOAD_READY_STATUS_REQ_V02),
+    NAME_VAL(QMI_LOC_GDT_DOWNLOAD_READY_STATUS_RESP_V02),
+    NAME_VAL(QMI_LOC_GDT_DOWNLOAD_READY_STATUS_IND_V02),
+    NAME_VAL(QMI_LOC_GDT_RECEIVE_DONE_STATUS_REQ_V02),
+    NAME_VAL(QMI_LOC_GDT_RECEIVE_DONE_STATUS_RESP_V02),
+    NAME_VAL(QMI_LOC_GDT_RECEIVE_DONE_STATUS_IND_V02),
+    NAME_VAL(QMI_LOC_GDT_DOWNLOAD_END_STATUS_REQ_V02),
+    NAME_VAL(QMI_LOC_GDT_DOWNLOAD_END_STATUS_RESP_V02),
+    NAME_VAL(QMI_LOC_GDT_DOWNLOAD_END_STATUS_IND_V02),
+    NAME_VAL(QMI_LOC_EVENT_GDT_DOWNLOAD_BEGIN_REQ_IND_V02),
+    NAME_VAL(QMI_LOC_EVENT_GDT_RECEIVE_DONE_IND_V02),
+    NAME_VAL(QMI_LOC_EVENT_GDT_DOWNLOAD_END_REQ_IND_V02),
+    NAME_VAL(QMI_LOC_INJECT_XTRA_DATA_REQ_V02),
+    NAME_VAL(QMI_LOC_INJECT_XTRA_DATA_RESP_V02),
+    NAME_VAL(QMI_LOC_INJECT_XTRA_DATA_IND_V02),
+    NAME_VAL(QMI_LOC_INJECT_XTRA_PCID_REQ_V02),
+    NAME_VAL(QMI_LOC_INJECT_XTRA_PCID_RESP_V02),
+    NAME_VAL(QMI_LOC_INJECT_XTRA_PCID_IND_V02),
+    NAME_VAL(QMI_LOC_GET_SUPPORTED_FEATURE_REQ_V02),
+    NAME_VAL(QMI_LOC_GET_SUPPORTED_FEATURE_RESP_V02),
+    NAME_VAL(QMI_LOC_GET_SUPPORTED_FEATURE_IND_V02),
+};
+static const int loc_v02_event_num = sizeof(loc_v02_event_name) / sizeof(loc_name_val_s_type);
+
+const char* loc_get_v02_event_name(uint32_t event)
+{
+    return loc_get_name_from_val(loc_v02_event_name, loc_v02_event_num, (long) event);
+}
+
+static const loc_name_val_s_type loc_v02_client_status_name[] =
+{
+    NAME_VAL(eLOC_CLIENT_SUCCESS),
+    NAME_VAL(eLOC_CLIENT_FAILURE_GENERAL),
+    NAME_VAL(eLOC_CLIENT_FAILURE_UNSUPPORTED),
+    NAME_VAL(eLOC_CLIENT_FAILURE_INVALID_PARAMETER),
+    NAME_VAL(eLOC_CLIENT_FAILURE_ENGINE_BUSY),
+    NAME_VAL(eLOC_CLIENT_FAILURE_PHONE_OFFLINE),
+    NAME_VAL(eLOC_CLIENT_FAILURE_TIMEOUT),
+    NAME_VAL(eLOC_CLIENT_FAILURE_SERVICE_NOT_PRESENT),
+    NAME_VAL(eLOC_CLIENT_FAILURE_SERVICE_VERSION_UNSUPPORTED),
+    NAME_VAL(eLOC_CLIENT_FAILURE_CLIENT_VERSION_UNSUPPORTED),
+    NAME_VAL(eLOC_CLIENT_FAILURE_INVALID_HANDLE),
+    NAME_VAL(eLOC_CLIENT_FAILURE_INTERNAL),
+    NAME_VAL(eLOC_CLIENT_FAILURE_NOT_INITIALIZED),
+    NAME_VAL(eLOC_CLIENT_FAILURE_NOT_ENOUGH_MEMORY),
+};
+static const int loc_v02_client_status_num = sizeof(loc_v02_client_status_name) / sizeof(loc_name_val_s_type);
+
+const char* loc_get_v02_client_status_name(locClientStatusEnumType status)
+{
+    return loc_get_name_from_val(loc_v02_client_status_name, loc_v02_client_status_num, (long) status);
+}
+
+
+static const loc_name_val_s_type loc_v02_qmi_status_name[] =
+{
+    NAME_VAL(eQMI_LOC_SUCCESS_V02),
+    NAME_VAL(eQMI_LOC_GENERAL_FAILURE_V02),
+    NAME_VAL(eQMI_LOC_UNSUPPORTED_V02),
+    NAME_VAL(eQMI_LOC_INVALID_PARAMETER_V02),
+    NAME_VAL(eQMI_LOC_ENGINE_BUSY_V02),
+    NAME_VAL(eQMI_LOC_PHONE_OFFLINE_V02),
+    NAME_VAL(eQMI_LOC_TIMEOUT_V02),
+    NAME_VAL(eQMI_LOC_CONFIG_NOT_SUPPORTED_V02),
+    NAME_VAL(eQMI_LOC_INSUFFICIENT_MEMORY_V02),
+};
+static const int loc_v02_qmi_status_num = sizeof(loc_v02_qmi_status_name) / sizeof(loc_name_val_s_type);
+
+const char* loc_get_v02_qmi_status_name(qmiLocStatusEnumT_v02 status)
+{
+    return loc_get_name_from_val(loc_v02_qmi_status_name, loc_v02_qmi_status_num, (long) status);
+}
diff --git a/gps/loc_api/loc_api_v02/loc_api_v02_log.h b/gps/loc_api/loc_api_v02/loc_api_v02_log.h
new file mode 100644
index 0000000..8d4670c
--- /dev/null
+++ b/gps/loc_api/loc_api_v02/loc_api_v02_log.h
@@ -0,0 +1,50 @@
+/* Copyright (c) 2011, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of The Linux Foundation nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef LOC_API_V02_LOG_H
+#define LOC_API_V02_LOG_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include <loc_log.h>
+#include <loc_api_v02_client.h>
+
+const char* loc_get_v02_event_name(uint32_t event);
+const char* loc_get_v02_client_status_name(locClientStatusEnumType status);
+const char* loc_get_v02_qmi_status_name(qmiLocStatusEnumT_v02 status);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LOC_API_V02_LOG_H */
diff --git a/gps/loc_api/loc_api_v02/loc_util_log.h b/gps/loc_api/loc_api_v02/loc_util_log.h
new file mode 100644
index 0000000..f3deed4
--- /dev/null
+++ b/gps/loc_api/loc_api_v02/loc_util_log.h
@@ -0,0 +1,86 @@
+/* Copyright (c) 2011-2012, 2014, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of The Linux Foundation, nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef LOC_UTIL_LOG_H
+#define LOC_UTIL_LOG_H
+
+#include <platform_lib_log_util.h>
+
+#if defined(_ANDROID_)
+#include "loc_api_v02_log.h"
+
+#else // no _ANDROID_
+
+#if defined(__LOC_API_V02_LOG_SILENT__)
+#define MSG_LOG
+#define LOC_LOGE(...) MSG_LOG(__VA_ARGS__);
+#define LOC_LOGW(...) MSG_LOG(__VA_ARGS__);
+#define LOC_LOGD(...) MSG_LOG(__VA_ARGS__);
+#define LOC_LOGI(...) MSG_LOG(__VA_ARGS__);
+#define LOC_LOGV(...) MSG_LOG(__VA_ARGS__);
+#elif !defined(USE_GLIB)
+
+// common for QNX and Griffon
+
+//error logs
+#define LOC_LOGE(...) printf(__VA_ARGS__)
+//warning logs
+#define LOC_LOGW(...) printf(__VA_ARGS__)
+// debug logs
+#define LOC_LOGD(...) printf(__VA_ARGS__)
+//info logs
+#define LOC_LOGI(...) printf(__VA_ARGS__)
+//verbose logs
+#define LOC_LOGV(...) printf(__VA_ARGS__)
+#endif //__LOC_API_V02_LOG_SILENT__
+
+#define MODEM_LOG_CALLFLOW(SPEC, VAL)
+#define EXIT_LOG_CALLFLOW(SPEC, VAL)
+
+#define loc_get_v02_event_name(X) #X
+#define loc_get_v02_client_status_name(X) #X
+
+#define loc_get_v02_qmi_status_name(X)  #X
+
+//specific to OFF TARGET
+#ifdef LOC_UTIL_TARGET_OFF_TARGET
+
+# include <stdio.h>
+# include <asm/errno.h>
+# include <sys/time.h>
+
+// get around strl*: not found in glibc
+// TBD:look for presence of eglibc other libraries
+// with strlcpy supported.
+#define strlcpy(X,Y,Z) strcpy(X,Y)
+#define strlcat(X,Y,Z) strcat(X,Y)
+
+#endif //LOC_UTIL_TARGET_OFF_TARGET
+
+#endif //_ANDROID_
+
+#endif //LOC_UTIL_LOG_H
diff --git a/gps/loc_api/loc_api_v02/location_service_v02.c b/gps/loc_api/loc_api_v02/location_service_v02.c
new file mode 100644
index 0000000..16916ca
--- /dev/null
+++ b/gps/loc_api/loc_api_v02/location_service_v02.c
@@ -0,0 +1,6163 @@
+/* Copyright (c) 2011-2016, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of The Linux Foundation, nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/*====*====*====*====*====*====*====*====*====*====*====*====*====*====*====*
+ *THIS IS AN AUTO GENERATED FILE. DO NOT ALTER IN ANY WAY
+ *====*====*====*====*====*====*====*====*====*====*====*====*====*====*====*/
+
+/* This file was generated with Tool version 6.14.7
+   It was generated on: Tue Jun 28 2016 (Spin 0)
+   From IDL File: location_service_v02.idl */
+
+#include "stdint.h"
+#include "qmi_idl_lib_internal.h"
+#include "location_service_v02.h"
+#include "common_v01.h"
+
+
+/*Type Definitions*/
+static const uint8_t qmiLocApplicationIdStructT_data_v02[] = {
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |QMI_IDL_STRING,
+  QMI_IDL_OFFSET8(qmiLocApplicationIdStructT_v02, applicationProvider),
+  QMI_LOC_MAX_APP_ID_PROVIDER_LENGTH_V02,
+
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |QMI_IDL_STRING,
+  QMI_IDL_OFFSET8(qmiLocApplicationIdStructT_v02, applicationName),
+  QMI_LOC_MAX_APP_ID_NAME_LENGTH_V02,
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocApplicationIdStructT_v02, applicationVersion_valid),
+
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |QMI_IDL_STRING,
+  QMI_IDL_OFFSET8(qmiLocApplicationIdStructT_v02, applicationVersion),
+  QMI_LOC_MAX_APP_ID_VERSION_LENGTH_V02,
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocGPSTimeStructT_data_v02[] = {
+  QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGPSTimeStructT_v02, gpsWeek),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGPSTimeStructT_v02, gpsTimeOfWeekMs),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocDOPStructT_data_v02[] = {
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDOPStructT_v02, PDOP),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDOPStructT_v02, HDOP),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDOPStructT_v02, VDOP),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocSensorUsageIndicatorStructT_data_v02[] = {
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSensorUsageIndicatorStructT_v02, usageMask),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSensorUsageIndicatorStructT_v02, aidingIndicatorMask),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocSvInfoStructT_data_v02[] = {
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSvInfoStructT_v02, validMask),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSvInfoStructT_v02, system),
+
+  QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSvInfoStructT_v02, gnssSvId),
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSvInfoStructT_v02, healthStatus),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSvInfoStructT_v02, svStatus),
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSvInfoStructT_v02, svInfoMask),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSvInfoStructT_v02, elevation),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSvInfoStructT_v02, azimuth),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSvInfoStructT_v02, snr),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocNiVxNotifyVerifyStructT_data_v02[] = {
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNiVxNotifyVerifyStructT_v02, posQosIncl),
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNiVxNotifyVerifyStructT_v02, posQos),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNiVxNotifyVerifyStructT_v02, numFixes),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNiVxNotifyVerifyStructT_v02, timeBetweenFixes),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNiVxNotifyVerifyStructT_v02, posMode),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNiVxNotifyVerifyStructT_v02, encodingScheme),
+
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNiVxNotifyVerifyStructT_v02, requestorId),
+  QMI_LOC_NI_MAX_REQUESTOR_ID_LENGTH_V02,
+  QMI_IDL_OFFSET8(qmiLocNiVxNotifyVerifyStructT_v02, requestorId) - QMI_IDL_OFFSET8(qmiLocNiVxNotifyVerifyStructT_v02, requestorId_len),
+
+  QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocNiVxNotifyVerifyStructT_v02, userRespTimerInSeconds),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocNiSuplFormattedStringStructT_data_v02[] = {
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNiSuplFormattedStringStructT_v02, formatType),
+
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNiSuplFormattedStringStructT_v02, formattedString),
+  QMI_LOC_NI_MAX_CLIENT_NAME_LENGTH_V02,
+  QMI_IDL_OFFSET8(qmiLocNiSuplFormattedStringStructT_v02, formattedString) - QMI_IDL_OFFSET8(qmiLocNiSuplFormattedStringStructT_v02, formattedString_len),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocNiSuplQopStructT_data_v02[] = {
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNiSuplQopStructT_v02, validMask),
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNiSuplQopStructT_v02, horizontalAccuracy),
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNiSuplQopStructT_v02, verticalAccuracy),
+
+  QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNiSuplQopStructT_v02, maxLocAge),
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNiSuplQopStructT_v02, delay),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocIpV4AddrStructType_data_v02[] = {
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocIpV4AddrStructType_v02, addr),
+
+  QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocIpV4AddrStructType_v02, port),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocIpV6AddrStructType_data_v02[] = {
+  QMI_IDL_FLAGS_IS_ARRAY |QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocIpV6AddrStructType_v02, addr),
+  QMI_LOC_IPV6_ADDR_LENGTH_V02,
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocIpV6AddrStructType_v02, port),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocNiSuplServerInfoStructT_data_v02[] = {
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNiSuplServerInfoStructT_v02, suplServerAddrTypeMask),
+
+  QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocNiSuplServerInfoStructT_v02, ipv4Addr),
+  QMI_IDL_TYPE88(0, 8),
+  QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocNiSuplServerInfoStructT_v02, ipv6Addr),
+  QMI_IDL_TYPE88(0, 9),
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |QMI_IDL_STRING,
+  QMI_IDL_OFFSET8(qmiLocNiSuplServerInfoStructT_v02, urlAddr),
+  QMI_LOC_MAX_SERVER_ADDR_LENGTH_V02,
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocNiSuplNotifyVerifyStructT_data_v02[] = {
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNiSuplNotifyVerifyStructT_v02, valid_flags),
+
+  QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocNiSuplNotifyVerifyStructT_v02, suplServerInfo),
+  QMI_IDL_TYPE88(0, 10),
+  QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_FLAGS_IS_ARRAY |QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocNiSuplNotifyVerifyStructT_v02, suplSessionId),
+  QMI_LOC_NI_SUPL_SLP_SESSION_ID_BYTE_LENGTH_V02,
+
+  QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_FLAGS_IS_ARRAY |QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocNiSuplNotifyVerifyStructT_v02, suplHash),
+  QMI_LOC_NI_SUPL_HASH_LENGTH_V02,
+
+  QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocNiSuplNotifyVerifyStructT_v02, posMethod),
+
+  QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocNiSuplNotifyVerifyStructT_v02, dataCodingScheme),
+
+  QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocNiSuplNotifyVerifyStructT_v02, requestorId),
+  QMI_IDL_TYPE88(0, 6),
+  QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocNiSuplNotifyVerifyStructT_v02, clientName),
+  QMI_IDL_TYPE88(0, 6),
+  QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocNiSuplNotifyVerifyStructT_v02, suplQop),
+  QMI_IDL_TYPE88(0, 7),
+  QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocNiSuplNotifyVerifyStructT_v02, userResponseTimer),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocNiUmtsCpCodedStringStructT_data_v02[] = {
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNiUmtsCpCodedStringStructT_v02, dataCodingScheme),
+
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNiUmtsCpCodedStringStructT_v02, codedString),
+  QMI_LOC_NI_CODEWORD_MAX_LENGTH_V02,
+  QMI_IDL_OFFSET8(qmiLocNiUmtsCpCodedStringStructT_v02, codedString) - QMI_IDL_OFFSET8(qmiLocNiUmtsCpCodedStringStructT_v02, codedString_len),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocNiUmtsCpNotifyVerifyStructT_data_v02[] = {
+  QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNiUmtsCpNotifyVerifyStructT_v02, valid_flags),
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNiUmtsCpNotifyVerifyStructT_v02, invokeId),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNiUmtsCpNotifyVerifyStructT_v02, dataCodingScheme),
+
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNiUmtsCpNotifyVerifyStructT_v02, notificationText),
+  QMI_LOC_NI_MAX_CLIENT_NAME_LENGTH_V02,
+  QMI_IDL_OFFSET8(qmiLocNiUmtsCpNotifyVerifyStructT_v02, notificationText) - QMI_IDL_OFFSET8(qmiLocNiUmtsCpNotifyVerifyStructT_v02, notificationText_len),
+
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNiUmtsCpNotifyVerifyStructT_v02, clientAddress),
+  QMI_LOC_NI_MAX_EXT_CLIENT_ADDRESS_V02,
+  QMI_IDL_OFFSET8(qmiLocNiUmtsCpNotifyVerifyStructT_v02, clientAddress) - QMI_IDL_OFFSET8(qmiLocNiUmtsCpNotifyVerifyStructT_v02, clientAddress_len),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNiUmtsCpNotifyVerifyStructT_v02, locationType),
+
+  QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocNiUmtsCpNotifyVerifyStructT_v02, requestorId),
+  QMI_IDL_TYPE88(0, 12),
+  QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocNiUmtsCpNotifyVerifyStructT_v02, codewordString),
+  QMI_IDL_TYPE88(0, 12),
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNiUmtsCpNotifyVerifyStructT_v02, lcsServiceTypeId),
+
+  QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNiUmtsCpNotifyVerifyStructT_v02, userResponseTimer),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocNiVxServiceInteractionStructT_data_v02[] = {
+  QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocNiVxServiceInteractionStructT_v02, niVxReq),
+  QMI_IDL_TYPE88(0, 5),
+  QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocNiVxServiceInteractionStructT_v02, serviceInteractionType),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocNiSuplVer2ExtStructT_data_v02[] = {
+  QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNiSuplVer2ExtStructT_v02, supportedNetworksMask),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNiSuplVer2ExtStructT_v02, triggerType),
+
+  QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNiSuplVer2ExtStructT_v02, gnssType),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocEmergencyNotificationStructT_data_v02[] = {
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |QMI_IDL_STRING,
+  QMI_IDL_OFFSET8(qmiLocEmergencyNotificationStructT_v02, eslpUrl),
+  QMI_LOC_MAX_SERVER_ADDR_LENGTH_V02,
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocAssistanceServerUrlStructT_data_v02[] = {
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |QMI_IDL_STRING,
+  QMI_IDL_OFFSET8(qmiLocAssistanceServerUrlStructT_v02, serverUrl),
+  QMI_LOC_MAX_SERVER_ADDR_LENGTH_V02,
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocTimeServerListStructT_data_v02[] = {
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocTimeServerListStructT_v02, delayThreshold),
+
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocTimeServerListStructT_v02, timeServerList),
+  QMI_LOC_MAX_NTP_SERVERS_V02,
+  QMI_IDL_OFFSET8(qmiLocTimeServerListStructT_v02, timeServerList) - QMI_IDL_OFFSET8(qmiLocTimeServerListStructT_v02, timeServerList_len),
+  QMI_IDL_TYPE88(0, 17),
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocPredictedOrbitsAllowedSizesStructT_data_v02[] = {
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocPredictedOrbitsAllowedSizesStructT_v02, maxFileSizeInBytes),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocPredictedOrbitsAllowedSizesStructT_v02, maxPartSize),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocPredictedOrbitsServerListStructT_data_v02[] = {
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocPredictedOrbitsServerListStructT_v02, serverList),
+  QMI_LOC_MAX_PREDICTED_ORBITS_SERVERS_V02,
+  QMI_IDL_OFFSET8(qmiLocPredictedOrbitsServerListStructT_v02, serverList) - QMI_IDL_OFFSET8(qmiLocPredictedOrbitsServerListStructT_v02, serverList_len),
+  QMI_IDL_TYPE88(0, 17),
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocSensorControlConfigSamplingSpecStructT_data_v02[] = {
+  QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSensorControlConfigSamplingSpecStructT_v02, samplesPerBatch),
+
+  QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSensorControlConfigSamplingSpecStructT_v02, batchesPerSecond),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocSensorReadyStatusStructT_data_v02[] = {
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSensorReadyStatusStructT_v02, injectEnable),
+
+  QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocSensorReadyStatusStructT_v02, dataFrequency),
+  QMI_IDL_TYPE88(0, 21),
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocGeofencePositionStructT_data_v02[] = {
+  QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGeofencePositionStructT_v02, timestampUtc),
+
+  QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGeofencePositionStructT_v02, latitude),
+
+  QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGeofencePositionStructT_v02, longitude),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGeofencePositionStructT_v02, horUncEllipseSemiMinor),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGeofencePositionStructT_v02, horUncEllipseSemiMajor),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGeofencePositionStructT_v02, horUncEllipseOrientAzimuth),
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGeofencePositionStructT_v02, speedHorizontal_valid),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGeofencePositionStructT_v02, speedHorizontal),
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGeofencePositionStructT_v02, altitudeWrtEllipsoid_valid),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGeofencePositionStructT_v02, altitudeWrtEllipsoid),
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGeofencePositionStructT_v02, vertUnc_valid),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGeofencePositionStructT_v02, vertUnc),
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGeofencePositionStructT_v02, speedVertical_valid),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGeofencePositionStructT_v02, speedVertical),
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGeofencePositionStructT_v02, heading_valid),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGeofencePositionStructT_v02, heading),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocGeofenceIdContinuousStructT_data_v02[] = {
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGeofenceIdContinuousStructT_v02, idLow),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGeofenceIdContinuousStructT_v02, idHigh),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocPredictedOrbitsDataValidityStructT_data_v02[] = {
+  QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocPredictedOrbitsDataValidityStructT_v02, startTimeInUTC),
+
+  QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocPredictedOrbitsDataValidityStructT_v02, durationHours),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocAltitudeSrcInfoStructT_data_v02[] = {
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocAltitudeSrcInfoStructT_v02, source),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocAltitudeSrcInfoStructT_v02, linkage),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocAltitudeSrcInfoStructT_v02, coverage),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocDeleteSvInfoStructT_data_v02[] = {
+  QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDeleteSvInfoStructT_v02, gnssSvId),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDeleteSvInfoStructT_v02, system),
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDeleteSvInfoStructT_v02, deleteSvInfoMask),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocDeleteBDSSvInfoStructT_data_v02[] = {
+  QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDeleteBDSSvInfoStructT_v02, gnssSvId),
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDeleteBDSSvInfoStructT_v02, deleteSvInfoMask),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocDeleteGALSvInfoStructT_data_v02[] = {
+  QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDeleteGALSvInfoStructT_v02, gnssSvId),
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDeleteGALSvInfoStructT_v02, deleteSvInfoMask),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocWifiFixTimeStructT_data_v02[] = {
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocWifiFixTimeStructT_v02, wifiPositionTime),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocWifiFixPosStructT_data_v02[] = {
+  QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocWifiFixPosStructT_v02, lat),
+
+  QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocWifiFixPosStructT_v02, lon),
+
+  QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocWifiFixPosStructT_v02, hepe),
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocWifiFixPosStructT_v02, numApsUsed),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocWifiFixPosStructT_v02, fixErrorCode),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocWifiApInfoStructT_data_v02[] = {
+  QMI_IDL_FLAGS_IS_ARRAY |QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocWifiApInfoStructT_v02, macAddr),
+  QMI_LOC_WIFI_MAC_ADDR_LENGTH_V02,
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocWifiApInfoStructT_v02, rssi),
+
+  QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocWifiApInfoStructT_v02, channel),
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocWifiApInfoStructT_v02, apQualifier),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocWifiApSsidStructT_data_v02[] = {
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |QMI_IDL_STRING,
+  QMI_IDL_OFFSET8(qmiLocWifiApSsidStructT_v02, ssid),
+  QMI_LOC_MAX_WIFI_AP_SSID_STR_LENGTH_V02,
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLoc3AxisSensorSampleStructT_data_v02[] = {
+  QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLoc3AxisSensorSampleStructT_v02, timeOffset),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLoc3AxisSensorSampleStructT_v02, xAxis),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLoc3AxisSensorSampleStructT_v02, yAxis),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLoc3AxisSensorSampleStructT_v02, zAxis),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLoc3AxisSensorSampleListStructT_data_v02[] = {
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLoc3AxisSensorSampleListStructT_v02, timeOfFirstSample),
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLoc3AxisSensorSampleListStructT_v02, flags),
+
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLoc3AxisSensorSampleListStructT_v02, sensorData),
+  QMI_LOC_SENSOR_DATA_MAX_SAMPLES_V02,
+  QMI_IDL_OFFSET8(qmiLoc3AxisSensorSampleListStructT_v02, sensorData) - QMI_IDL_OFFSET8(qmiLoc3AxisSensorSampleListStructT_v02, sensorData_len),
+  QMI_IDL_TYPE88(0, 34),
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocSensorTemperatureSampleStructT_data_v02[] = {
+  QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSensorTemperatureSampleStructT_v02, timeOffset),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSensorTemperatureSampleStructT_v02, temperature),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocSensorTemperatureSampleListStructT_data_v02[] = {
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSensorTemperatureSampleListStructT_v02, timeSource),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSensorTemperatureSampleListStructT_v02, timeOfFirstSample),
+
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocSensorTemperatureSampleListStructT_v02, temperatureData),
+  QMI_LOC_SENSOR_DATA_MAX_SAMPLES_V02,
+  QMI_IDL_OFFSET8(qmiLocSensorTemperatureSampleListStructT_v02, temperatureData) - QMI_IDL_OFFSET8(qmiLocSensorTemperatureSampleListStructT_v02, temperatureData_len),
+  QMI_IDL_TYPE88(0, 36),
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocApnProfilesStructT_data_v02[] = {
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocApnProfilesStructT_v02, pdnType),
+
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |QMI_IDL_STRING,
+  QMI_IDL_OFFSET8(qmiLocApnProfilesStructT_v02, apnName),
+  QMI_LOC_MAX_APN_NAME_LENGTH_V02,
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocCircularGeofenceArgsStructT_data_v02[] = {
+  QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocCircularGeofenceArgsStructT_v02, latitude),
+
+  QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocCircularGeofenceArgsStructT_v02, longitude),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocCircularGeofenceArgsStructT_v02, radius),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocGeofenceMotionStateConfigStructT_data_v02[] = {
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGeofenceMotionStateConfigStructT_v02, motionState),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGeofenceMotionStateConfigStructT_v02, motionStateSpeed),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocTimeZoneStructT_data_v02[] = {
+  QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocTimeZoneStructT_v02, dstOffset),
+
+  QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocTimeZoneStructT_v02, rawOffset),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocMotionDataStructT_data_v02[] = {
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocMotionDataStructT_v02, motion_state),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocMotionDataStructT_v02, motion_mode),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocMotionDataStructT_v02, probability_of_state),
+
+  QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocMotionDataStructT_v02, age),
+
+  QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocMotionDataStructT_v02, timeout),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocGSMCellIdStructT_data_v02[] = {
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGSMCellIdStructT_v02, MCC),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGSMCellIdStructT_v02, MNC),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGSMCellIdStructT_v02, LAC),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGSMCellIdStructT_v02, CID),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocWCDMACellIdStructT_data_v02[] = {
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocWCDMACellIdStructT_v02, mcc),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocWCDMACellIdStructT_v02, mnc),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocWCDMACellIdStructT_v02, cid),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocTDSCDMACellIdStructT_data_v02[] = {
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocTDSCDMACellIdStructT_v02, mcc),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocTDSCDMACellIdStructT_v02, mnc),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocTDSCDMACellIdStructT_v02, cid),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocTDSCDMACellIdStructT_v02, lac),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocBatchedReportStructT_data_v02[] = {
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocBatchedReportStructT_v02, fixId),
+
+  QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocBatchedReportStructT_v02, validFields),
+
+  QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocBatchedReportStructT_v02, latitude),
+
+  QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocBatchedReportStructT_v02, longitude),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocBatchedReportStructT_v02, horUncCircular),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocBatchedReportStructT_v02, speedHorizontal),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocBatchedReportStructT_v02, speedUnc),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocBatchedReportStructT_v02, altitudeWrtEllipsoid),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocBatchedReportStructT_v02, speedVertical),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocBatchedReportStructT_v02, heading),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocBatchedReportStructT_v02, headingUnc),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocBatchedReportStructT_v02, technologyMask),
+
+  QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocBatchedReportStructT_v02, timestampUtc),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocBatchedReportStructT_v02, timeUnc),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocBatchedReportStructT_v02, magneticDeviation),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocBatchedReportStructT_v02, vertUnc),
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocBatchedReportStructT_v02, horConfidence),
+
+  QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocBatchedReportStructT_v02, gpsTime),
+  QMI_IDL_TYPE88(0, 1),
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocWifiApDataStructT_data_v02[] = {
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocWifiApDataStructT_v02, wifiApDataMask),
+
+  QMI_IDL_FLAGS_IS_ARRAY |QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocWifiApDataStructT_v02, macAddress),
+  QMI_LOC_WIFI_MAC_ADDR_LENGTH_V02,
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocWifiApDataStructT_v02, apTransmitPower),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocWifiApDataStructT_v02, apAntennaGain),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocWifiApDataStructT_v02, apSignalToNoise),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocWifiApDataStructT_v02, apDeviceType),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocWifiApDataStructT_v02, apRssi),
+
+  QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocWifiApDataStructT_v02, apChannel),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocWifiApDataStructT_v02, apRoundTripDelay),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocWifiApDataStructT_v02, apRoundTripDelayUnit),
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocWifiApDataStructT_v02, apRoundTripDelayAccuracy),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocWifiApDataStructT_v02, mobileSignalToNoise),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocWifiApDataStructT_v02, mobileRssi),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocWifiApAdditionalDataStructT_data_v02[] = {
+  QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocWifiApAdditionalDataStructT_v02, rssiTimestamp),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocWifiApAdditionalDataStructT_v02, measAge),
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocWifiApAdditionalDataStructT_v02, servingAccessPoint),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocWifiApAdditionalDataStructT_v02, channelFrequency),
+
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |QMI_IDL_STRING,
+  QMI_IDL_OFFSET8(qmiLocWifiApAdditionalDataStructT_v02, ssid),
+  QMI_LOC_MAX_WIFI_AP_SSID_STR_LENGTH_V02,
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocWifiApAdditionalDataStructT_v02, apHighResolutionRssi),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocVehicleSensorSampleStructT_data_v02[] = {
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocVehicleSensorSampleStructT_v02, timeOffset),
+
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocVehicleSensorSampleStructT_v02, axisSample),
+  QMI_LOC_VEHICLE_SENSOR_DATA_MAX_AXES_V02,
+  QMI_IDL_OFFSET8(qmiLocVehicleSensorSampleStructT_v02, axisSample) - QMI_IDL_OFFSET8(qmiLocVehicleSensorSampleStructT_v02, axisSample_len),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocVehicleSensorSampleListStructType_data_v02[] = {
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocVehicleSensorSampleListStructType_v02, sampleTimeBase),
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocVehicleSensorSampleListStructType_v02, axesValidity),
+
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocVehicleSensorSampleListStructType_v02, sensorData),
+  QMI_LOC_VEHICLE_SENSOR_DATA_MAX_SAMPLES_V02,
+  QMI_IDL_OFFSET8(qmiLocVehicleSensorSampleListStructType_v02, sensorData) - QMI_IDL_OFFSET8(qmiLocVehicleSensorSampleListStructType_v02, sensorData_len),
+  QMI_IDL_TYPE88(0, 49),
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocVehicleOdometrySampleStructT_data_v02[] = {
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocVehicleOdometrySampleStructT_v02, timeOffset),
+
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocVehicleOdometrySampleStructT_v02, distanceTravelled),
+  QMI_LOC_VEHICLE_ODOMETRY_MAX_MEASUREMENTS_V02,
+  QMI_IDL_OFFSET8(qmiLocVehicleOdometrySampleStructT_v02, distanceTravelled) - QMI_IDL_OFFSET8(qmiLocVehicleOdometrySampleStructT_v02, distanceTravelled_len),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocVehicleOdometrySampleListStructT_data_v02[] = {
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocVehicleOdometrySampleListStructT_v02, sampleTimeBase),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocVehicleOdometrySampleListStructT_v02, flags),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocVehicleOdometrySampleListStructT_v02, wheelFlags),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocVehicleOdometrySampleListStructT_v02, distanceTravelledBase),
+
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocVehicleOdometrySampleListStructT_v02, odometryData),
+  QMI_LOC_VEHICLE_SENSOR_DATA_MAX_SAMPLES_V02,
+  QMI_IDL_OFFSET8(qmiLocVehicleOdometrySampleListStructT_v02, odometryData) - QMI_IDL_OFFSET8(qmiLocVehicleOdometrySampleListStructT_v02, odometryData_len),
+  QMI_IDL_TYPE88(0, 51),
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocRcvrClockFrequencyInfoStructT_data_v02[] = {
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocRcvrClockFrequencyInfoStructT_v02, clockDrift),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocRcvrClockFrequencyInfoStructT_v02, clockDriftUnc),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocRcvrClockFrequencyInfoStructT_v02, sourceOfFreq),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocLeapSecondInfoStructT_data_v02[] = {
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocLeapSecondInfoStructT_v02, leapSec),
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocLeapSecondInfoStructT_v02, leapSecUnc),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocInterSystemBiasStructT_data_v02[] = {
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInterSystemBiasStructT_v02, validMask),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInterSystemBiasStructT_v02, timeBias),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInterSystemBiasStructT_v02, timeBiasUnc),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocGnssTimeStructT_data_v02[] = {
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGnssTimeStructT_v02, system),
+
+  QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGnssTimeStructT_v02, systemWeek),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGnssTimeStructT_v02, systemMsec),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGnssTimeStructT_v02, systemClkTimeBias),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGnssTimeStructT_v02, systemClkTimeUncMs),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocGloTimeStructT_data_v02[] = {
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGloTimeStructT_v02, gloFourYear),
+
+  QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGloTimeStructT_v02, gloDays),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGloTimeStructT_v02, gloMsec),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGloTimeStructT_v02, gloClkTimeBias),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGloTimeStructT_v02, gloClkTimeUncMs),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocGnssTimeExtStructT_data_v02[] = {
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGnssTimeExtStructT_v02, refFCount),
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGnssTimeExtStructT_v02, systemRtc_valid),
+
+  QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGnssTimeExtStructT_v02, systemRtcMs),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGnssTimeExtStructT_v02, sourceOfTime),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocSVTimeSpeedStructT_data_v02[] = {
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSVTimeSpeedStructT_v02, svTimeMs),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSVTimeSpeedStructT_v02, svTimeSubMs),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSVTimeSpeedStructT_v02, svTimeUncMs),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSVTimeSpeedStructT_v02, dopplerShift),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSVTimeSpeedStructT_v02, dopplerShiftUnc),
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSVTimeSpeedStructT_v02, dopplerAccel_valid),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSVTimeSpeedStructT_v02, dopplerAccel),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocSVMeasurementStructT_data_v02[] = {
+  QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSVMeasurementStructT_v02, gnssSvId),
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSVMeasurementStructT_v02, gloFrequency),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSVMeasurementStructT_v02, svStatus),
+
+  QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSVMeasurementStructT_v02, validMask),
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSVMeasurementStructT_v02, healthStatus),
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSVMeasurementStructT_v02, svInfoMask),
+
+  QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSVMeasurementStructT_v02, validMeasStatusMask),
+
+  QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSVMeasurementStructT_v02, measurementStatus),
+
+  QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSVMeasurementStructT_v02, CNo),
+
+  QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSVMeasurementStructT_v02, gloRfLoss),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSVMeasurementStructT_v02, measLatency),
+
+  QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocSVMeasurementStructT_v02, svTimeSpeed),
+  QMI_IDL_TYPE88(0, 59),
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSVMeasurementStructT_v02, lossOfLock),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSVMeasurementStructT_v02, multipathEstimate),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSVMeasurementStructT_v02, fineSpeed),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSVMeasurementStructT_v02, fineSpeedUnc),
+
+  QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSVMeasurementStructT_v02, carrierPhase),
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSVMeasurementStructT_v02, cycleSlipCount),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSVMeasurementStructT_v02, svAzimuth),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSVMeasurementStructT_v02, svElevation),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocWifiApMacAddressStructT_data_v02[] = {
+  QMI_IDL_FLAGS_IS_ARRAY |QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocWifiApMacAddressStructT_v02, wifiApMacAddress),
+  QMI_LOC_WIFI_MAC_ADDR_LENGTH_V02,
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocIBeaconIdStructT_data_v02[] = {
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |QMI_IDL_STRING,
+  QMI_IDL_OFFSET8(qmiLocIBeaconIdStructT_v02, uuid),
+  QMI_LOC_MAX_IBEACON_UUID_STR_LENGTH_V02,
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocIBeaconIdStructT_v02, majorNumber),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocIBeaconIdStructT_v02, minorNumber),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocGtpAsnVerStructT_data_v02[] = {
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGtpAsnVerStructT_v02, asnMajorVersion),
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGtpAsnVerStructT_v02, asnMinorVersion),
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGtpAsnVerStructT_v02, asnPointVersion),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocDbtPositionStructT_data_v02[] = {
+  QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDbtPositionStructT_v02, timestampUtc),
+
+  QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDbtPositionStructT_v02, latitude),
+
+  QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDbtPositionStructT_v02, longitude),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDbtPositionStructT_v02, horUncEllipseSemiMinor),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDbtPositionStructT_v02, horUncEllipseSemiMajor),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDbtPositionStructT_v02, horUncEllipseOrientAzimuth),
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDbtPositionStructT_v02, speedHorizontal_valid),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDbtPositionStructT_v02, speedHorizontal),
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDbtPositionStructT_v02, altitudeWrtEllipsoid_valid),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDbtPositionStructT_v02, altitudeWrtEllipsoid),
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDbtPositionStructT_v02, vertUnc_valid),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDbtPositionStructT_v02, vertUnc),
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDbtPositionStructT_v02, speedVertical_valid),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDbtPositionStructT_v02, speedVertical),
+
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDbtPositionStructT_v02, heading_valid),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDbtPositionStructT_v02, heading),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocApCacheStructT_data_v02[] = {
+  QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocApCacheStructT_v02, macAddress),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocApCacheStructT_v02, xLat),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocApCacheStructT_v02, yLon),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocApCacheStructT_v02, mar),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocApCacheHepeRelStructT_data_v02[] = {
+  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocApCacheHepeRelStructT_v02, hepeValid),
+
+  QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocApCacheHepeRelStructT_v02, hepe),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocApCacheHepeRelStructT_v02, apReliability),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocApDoNotCacheStructT_data_v02[] = {
+  QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocApDoNotCacheStructT_v02, macAddress),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+static const uint8_t qmiLocDeleteSatelliteDataStructT_data_v02[] = {
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDeleteSatelliteDataStructT_v02, system),
+
+  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDeleteSatelliteDataStructT_v02, deleteSatelliteDataMask),
+
+  QMI_IDL_FLAG_END_VALUE
+};
+
+/*Message Definitions*/
+static const uint8_t qmiLocGenRespMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x02,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocGenRespMsgT_v02, resp),
+  QMI_IDL_TYPE88(1, 0)
+};
+
+static const uint8_t qmiLocInformClientRevisionReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInformClientRevisionReqMsgT_v02, revision)
+};
+
+static const uint8_t qmiLocRegEventsReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocRegEventsReqMsgT_v02, eventRegMask)
+};
+
+static const uint8_t qmiLocStartReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocStartReqMsgT_v02, sessionId),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocStartReqMsgT_v02, fixRecurrence) - QMI_IDL_OFFSET8(qmiLocStartReqMsgT_v02, fixRecurrence_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocStartReqMsgT_v02, fixRecurrence),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocStartReqMsgT_v02, horizontalAccuracyLevel) - QMI_IDL_OFFSET8(qmiLocStartReqMsgT_v02, horizontalAccuracyLevel_valid)),
+  0x11,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocStartReqMsgT_v02, horizontalAccuracyLevel),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocStartReqMsgT_v02, intermediateReportState) - QMI_IDL_OFFSET8(qmiLocStartReqMsgT_v02, intermediateReportState_valid)),
+  0x12,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocStartReqMsgT_v02, intermediateReportState),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocStartReqMsgT_v02, minInterval) - QMI_IDL_OFFSET8(qmiLocStartReqMsgT_v02, minInterval_valid)),
+  0x13,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocStartReqMsgT_v02, minInterval),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocStartReqMsgT_v02, applicationId) - QMI_IDL_OFFSET8(qmiLocStartReqMsgT_v02, applicationId_valid)),
+  0x14,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocStartReqMsgT_v02, applicationId),
+  QMI_IDL_TYPE88(0, 0),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocStartReqMsgT_v02, configAltitudeAssumed) - QMI_IDL_OFFSET8(qmiLocStartReqMsgT_v02, configAltitudeAssumed_valid)),
+  0x15,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocStartReqMsgT_v02, configAltitudeAssumed),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocStartReqMsgT_v02, minIntermediatePositionReportInterval) - QMI_IDL_OFFSET8(qmiLocStartReqMsgT_v02, minIntermediatePositionReportInterval_valid)),
+  0x16,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocStartReqMsgT_v02, minIntermediatePositionReportInterval),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocStartReqMsgT_v02, positionReportTimeout) - QMI_IDL_OFFSET8(qmiLocStartReqMsgT_v02, positionReportTimeout_valid)),
+  0x17,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocStartReqMsgT_v02, positionReportTimeout),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocStartReqMsgT_v02, sharePosition) - QMI_IDL_OFFSET8(qmiLocStartReqMsgT_v02, sharePosition_valid)),
+  0x18,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocStartReqMsgT_v02, sharePosition)
+};
+
+static const uint8_t qmiLocStopReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocStopReqMsgT_v02, sessionId)
+};
+
+static const uint8_t qmiLocEventPositionReportIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, sessionStatus),
+
+  0x02,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, sessionId),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, latitude) - QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, latitude_valid)),
+  0x10,
+   QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, latitude),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, longitude) - QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, longitude_valid)),
+  0x11,
+   QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, longitude),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, horUncCircular) - QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, horUncCircular_valid)),
+  0x12,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, horUncCircular),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, horUncEllipseSemiMinor) - QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, horUncEllipseSemiMinor_valid)),
+  0x13,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, horUncEllipseSemiMinor),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, horUncEllipseSemiMajor) - QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, horUncEllipseSemiMajor_valid)),
+  0x14,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, horUncEllipseSemiMajor),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, horUncEllipseOrientAzimuth) - QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, horUncEllipseOrientAzimuth_valid)),
+  0x15,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, horUncEllipseOrientAzimuth),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, horConfidence) - QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, horConfidence_valid)),
+  0x16,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, horConfidence),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, horReliability) - QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, horReliability_valid)),
+  0x17,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, horReliability),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, speedHorizontal) - QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, speedHorizontal_valid)),
+  0x18,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, speedHorizontal),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, speedUnc) - QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, speedUnc_valid)),
+  0x19,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, speedUnc),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, altitudeWrtEllipsoid) - QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, altitudeWrtEllipsoid_valid)),
+  0x1A,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, altitudeWrtEllipsoid),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, altitudeWrtMeanSeaLevel) - QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, altitudeWrtMeanSeaLevel_valid)),
+  0x1B,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, altitudeWrtMeanSeaLevel),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, vertUnc) - QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, vertUnc_valid)),
+  0x1C,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, vertUnc),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, vertConfidence) - QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, vertConfidence_valid)),
+  0x1D,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, vertConfidence),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, vertReliability) - QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, vertReliability_valid)),
+  0x1E,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, vertReliability),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, speedVertical) - QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, speedVertical_valid)),
+  0x1F,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, speedVertical),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, heading) - QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, heading_valid)),
+  0x20,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, heading),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, headingUnc) - QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, headingUnc_valid)),
+  0x21,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, headingUnc),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, magneticDeviation) - QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, magneticDeviation_valid)),
+  0x22,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, magneticDeviation),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, technologyMask) - QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, technologyMask_valid)),
+  0x23,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, technologyMask),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, DOP) - QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, DOP_valid)),
+  0x24,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, DOP),
+  QMI_IDL_TYPE88(0, 2),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, timestampUtc) - QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, timestampUtc_valid)),
+  0x25,
+   QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, timestampUtc),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, leapSeconds) - QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, leapSeconds_valid)),
+  0x26,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, leapSeconds),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, gpsTime) - QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, gpsTime_valid)),
+  0x27,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, gpsTime),
+  QMI_IDL_TYPE88(0, 1),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, timeUnc) - QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, timeUnc_valid)),
+  0x28,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventPositionReportIndMsgT_v02, timeUnc),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventPositionReportIndMsgT_v02, timeSrc) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventPositionReportIndMsgT_v02, timeSrc_valid)),
+  0x29,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventPositionReportIndMsgT_v02, timeSrc),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventPositionReportIndMsgT_v02, sensorDataUsage) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventPositionReportIndMsgT_v02, sensorDataUsage_valid)),
+  0x2A,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventPositionReportIndMsgT_v02, sensorDataUsage),
+  QMI_IDL_TYPE88(0, 3),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventPositionReportIndMsgT_v02, fixId) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventPositionReportIndMsgT_v02, fixId_valid)),
+  0x2B,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventPositionReportIndMsgT_v02, fixId),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventPositionReportIndMsgT_v02, gnssSvUsedList) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventPositionReportIndMsgT_v02, gnssSvUsedList_valid)),
+  0x2C,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventPositionReportIndMsgT_v02, gnssSvUsedList),
+  QMI_LOC_MAX_SV_USED_LIST_LENGTH_V02,
+  QMI_IDL_OFFSET16RELATIVE(qmiLocEventPositionReportIndMsgT_v02, gnssSvUsedList) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventPositionReportIndMsgT_v02, gnssSvUsedList_len),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventPositionReportIndMsgT_v02, altitudeAssumed) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventPositionReportIndMsgT_v02, altitudeAssumed_valid)),
+  0x2D,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventPositionReportIndMsgT_v02, altitudeAssumed),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventPositionReportIndMsgT_v02, velEnu) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventPositionReportIndMsgT_v02, velEnu_valid)),
+  0x2E,
+  QMI_IDL_FLAGS_IS_ARRAY |  QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventPositionReportIndMsgT_v02, velEnu),
+  QMI_LOC_ENU_ARRAY_LENGTH_V02,
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventPositionReportIndMsgT_v02, velUncEnu) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventPositionReportIndMsgT_v02, velUncEnu_valid)),
+  0x2F,
+  QMI_IDL_FLAGS_IS_ARRAY |  QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventPositionReportIndMsgT_v02, velUncEnu),
+  QMI_LOC_ENU_ARRAY_LENGTH_V02
+};
+
+static const uint8_t qmiLocEventGnssSvInfoIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGnssSvInfoIndMsgT_v02, altitudeAssumed),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventGnssSvInfoIndMsgT_v02, svList) - QMI_IDL_OFFSET8(qmiLocEventGnssSvInfoIndMsgT_v02, svList_valid)),
+  0x10,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocEventGnssSvInfoIndMsgT_v02, svList),
+  QMI_LOC_SV_INFO_LIST_MAX_SIZE_V02,
+  QMI_IDL_OFFSET8(qmiLocEventGnssSvInfoIndMsgT_v02, svList) - QMI_IDL_OFFSET8(qmiLocEventGnssSvInfoIndMsgT_v02, svList_len),
+  QMI_IDL_TYPE88(0, 4)
+};
+
+static const uint8_t qmiLocEventNmeaIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_STRING,
+  QMI_IDL_OFFSET8(qmiLocEventNmeaIndMsgT_v02, nmea),
+  QMI_LOC_NMEA_STRING_MAX_LENGTH_V02
+};
+
+static const uint8_t qmiLocEventNiNotifyVerifyReqIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventNiNotifyVerifyReqIndMsgT_v02, notificationType),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventNiNotifyVerifyReqIndMsgT_v02, NiVxInd) - QMI_IDL_OFFSET8(qmiLocEventNiNotifyVerifyReqIndMsgT_v02, NiVxInd_valid)),
+  0x10,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocEventNiNotifyVerifyReqIndMsgT_v02, NiVxInd),
+  QMI_IDL_TYPE88(0, 5),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventNiNotifyVerifyReqIndMsgT_v02, NiSuplInd) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventNiNotifyVerifyReqIndMsgT_v02, NiSuplInd_valid)),
+  0x11,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventNiNotifyVerifyReqIndMsgT_v02, NiSuplInd),
+  QMI_IDL_TYPE88(0, 11),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventNiNotifyVerifyReqIndMsgT_v02, NiUmtsCpInd) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventNiNotifyVerifyReqIndMsgT_v02, NiUmtsCpInd_valid)),
+  0x12,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventNiNotifyVerifyReqIndMsgT_v02, NiUmtsCpInd),
+  QMI_IDL_TYPE88(0, 13),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventNiNotifyVerifyReqIndMsgT_v02, NiVxServiceInteractionInd) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventNiNotifyVerifyReqIndMsgT_v02, NiVxServiceInteractionInd_valid)),
+  0x13,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventNiNotifyVerifyReqIndMsgT_v02, NiVxServiceInteractionInd),
+  QMI_IDL_TYPE88(0, 14),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventNiNotifyVerifyReqIndMsgT_v02, NiSuplVer2ExtInd) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventNiNotifyVerifyReqIndMsgT_v02, NiSuplVer2ExtInd_valid)),
+  0x14,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventNiNotifyVerifyReqIndMsgT_v02, NiSuplVer2ExtInd),
+  QMI_IDL_TYPE88(0, 15),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventNiNotifyVerifyReqIndMsgT_v02, suplEmergencyNotification) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventNiNotifyVerifyReqIndMsgT_v02, suplEmergencyNotification_valid)),
+  0x15,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventNiNotifyVerifyReqIndMsgT_v02, suplEmergencyNotification),
+  QMI_IDL_TYPE88(0, 16)
+};
+
+static const uint8_t qmiLocEventInjectTimeReqIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventInjectTimeReqIndMsgT_v02, timeServerInfo) - QMI_IDL_OFFSET8(qmiLocEventInjectTimeReqIndMsgT_v02, timeServerInfo_valid)),
+  0x10,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocEventInjectTimeReqIndMsgT_v02, timeServerInfo),
+  QMI_IDL_TYPE88(0, 18)
+};
+
+static const uint8_t qmiLocEventInjectPredictedOrbitsReqIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocEventInjectPredictedOrbitsReqIndMsgT_v02, allowedSizes),
+  QMI_IDL_TYPE88(0, 19),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventInjectPredictedOrbitsReqIndMsgT_v02, serverList) - QMI_IDL_OFFSET8(qmiLocEventInjectPredictedOrbitsReqIndMsgT_v02, serverList_valid)),
+  0x10,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocEventInjectPredictedOrbitsReqIndMsgT_v02, serverList),
+  QMI_IDL_TYPE88(0, 20)
+};
+
+static const uint8_t qmiLocEventInjectPositionReqIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventInjectPositionReqIndMsgT_v02, latitude),
+
+  0x02,
+   QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventInjectPositionReqIndMsgT_v02, longitude),
+
+  0x03,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventInjectPositionReqIndMsgT_v02, horUncCircular),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x04,
+   QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventInjectPositionReqIndMsgT_v02, timestampUtc)
+};
+
+static const uint8_t qmiLocEventEngineStateIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventEngineStateIndMsgT_v02, engineState)
+};
+
+static const uint8_t qmiLocEventFixSessionStateIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventFixSessionStateIndMsgT_v02, sessionState),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventFixSessionStateIndMsgT_v02, sessionId) - QMI_IDL_OFFSET8(qmiLocEventFixSessionStateIndMsgT_v02, sessionId_valid)),
+  0x10,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventFixSessionStateIndMsgT_v02, sessionId)
+};
+
+static const uint8_t qmiLocEventWifiReqIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventWifiReqIndMsgT_v02, requestType),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventWifiReqIndMsgT_v02, tbfInMs) - QMI_IDL_OFFSET8(qmiLocEventWifiReqIndMsgT_v02, tbfInMs_valid)),
+  0x10,
+   QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventWifiReqIndMsgT_v02, tbfInMs),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventWifiReqIndMsgT_v02, e911Mode) - QMI_IDL_OFFSET8(qmiLocEventWifiReqIndMsgT_v02, e911Mode_valid)),
+  0x11,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventWifiReqIndMsgT_v02, e911Mode)
+};
+
+static const uint8_t qmiLocEventSensorStreamingReadyStatusIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventSensorStreamingReadyStatusIndMsgT_v02, accelReady) - QMI_IDL_OFFSET8(qmiLocEventSensorStreamingReadyStatusIndMsgT_v02, accelReady_valid)),
+  0x10,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocEventSensorStreamingReadyStatusIndMsgT_v02, accelReady),
+  QMI_IDL_TYPE88(0, 22),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventSensorStreamingReadyStatusIndMsgT_v02, gyroReady) - QMI_IDL_OFFSET8(qmiLocEventSensorStreamingReadyStatusIndMsgT_v02, gyroReady_valid)),
+  0x11,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocEventSensorStreamingReadyStatusIndMsgT_v02, gyroReady),
+  QMI_IDL_TYPE88(0, 22),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventSensorStreamingReadyStatusIndMsgT_v02, accelTemperatureReady) - QMI_IDL_OFFSET8(qmiLocEventSensorStreamingReadyStatusIndMsgT_v02, accelTemperatureReady_valid)),
+  0x12,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocEventSensorStreamingReadyStatusIndMsgT_v02, accelTemperatureReady),
+  QMI_IDL_TYPE88(0, 22),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventSensorStreamingReadyStatusIndMsgT_v02, gyroTemperatureReady) - QMI_IDL_OFFSET8(qmiLocEventSensorStreamingReadyStatusIndMsgT_v02, gyroTemperatureReady_valid)),
+  0x13,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocEventSensorStreamingReadyStatusIndMsgT_v02, gyroTemperatureReady),
+  QMI_IDL_TYPE88(0, 22),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventSensorStreamingReadyStatusIndMsgT_v02, calibratedMagReady) - QMI_IDL_OFFSET8(qmiLocEventSensorStreamingReadyStatusIndMsgT_v02, calibratedMagReady_valid)),
+  0x14,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocEventSensorStreamingReadyStatusIndMsgT_v02, calibratedMagReady),
+  QMI_IDL_TYPE88(0, 22),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventSensorStreamingReadyStatusIndMsgT_v02, uncalibratedMagReady) - QMI_IDL_OFFSET8(qmiLocEventSensorStreamingReadyStatusIndMsgT_v02, uncalibratedMagReady_valid)),
+  0x15,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocEventSensorStreamingReadyStatusIndMsgT_v02, uncalibratedMagReady),
+  QMI_IDL_TYPE88(0, 22)
+};
+
+static const uint8_t qmiLocEventTimeSyncReqIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventTimeSyncReqIndMsgT_v02, refCounter)
+};
+
+static const uint8_t qmiLocEventSetSpiStreamingReportIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventSetSpiStreamingReportIndMsgT_v02, enable)
+};
+
+static const uint8_t qmiLocEventLocationServerConnectionReqIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventLocationServerConnectionReqIndMsgT_v02, connHandle),
+
+  0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventLocationServerConnectionReqIndMsgT_v02, requestType),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x03,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventLocationServerConnectionReqIndMsgT_v02, wwanType)
+};
+
+static const uint8_t qmiLocEventNiGeofenceNotificationIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventNiGeofenceNotificationIndMsgT_v02, geofenceId),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventNiGeofenceNotificationIndMsgT_v02, operationType)
+};
+
+static const uint8_t qmiLocEventGeofenceGenAlertIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGeofenceGenAlertIndMsgT_v02, geofenceAlert)
+};
+
+static const uint8_t qmiLocEventGeofenceBreachIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGeofenceBreachIndMsgT_v02, geofenceId),
+
+  0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGeofenceBreachIndMsgT_v02, breachType),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventGeofenceBreachIndMsgT_v02, geofencePosition) - QMI_IDL_OFFSET8(qmiLocEventGeofenceBreachIndMsgT_v02, geofencePosition_valid)),
+  0x10,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocEventGeofenceBreachIndMsgT_v02, geofencePosition),
+  QMI_IDL_TYPE88(0, 23),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventGeofenceBreachIndMsgT_v02, breachConfidence) - QMI_IDL_OFFSET8(qmiLocEventGeofenceBreachIndMsgT_v02, breachConfidence_valid)),
+  0x11,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGeofenceBreachIndMsgT_v02, breachConfidence)
+};
+
+static const uint8_t qmiLocEventPedometerControlIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventPedometerControlIndMsgT_v02, requestPedometerData),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventPedometerControlIndMsgT_v02, resetStepCount) - QMI_IDL_OFFSET8(qmiLocEventPedometerControlIndMsgT_v02, resetStepCount_valid)),
+  0x10,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventPedometerControlIndMsgT_v02, resetStepCount),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventPedometerControlIndMsgT_v02, stepCountThreshold) - QMI_IDL_OFFSET8(qmiLocEventPedometerControlIndMsgT_v02, stepCountThreshold_valid)),
+  0x11,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventPedometerControlIndMsgT_v02, stepCountThreshold)
+};
+
+static const uint8_t qmiLocEventMotionDataControlIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventMotionDataControlIndMsgT_v02, requestMotionData)
+};
+
+static const uint8_t qmiLocEventGeofenceBatchedBreachIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, breachType),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, geofenceIdContinuousList) - QMI_IDL_OFFSET8(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, geofenceIdContinuousList_valid)),
+  0x10,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, geofenceIdContinuousList),
+  QMI_LOC_MAX_GEOFENCE_ID_CONTINUOUS_LIST_LENGTH_V02,
+  QMI_IDL_OFFSET8(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, geofenceIdContinuousList) - QMI_IDL_OFFSET8(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, geofenceIdContinuousList_len),
+  QMI_IDL_TYPE88(0, 24),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, geofenceIdDiscreteList) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, geofenceIdDiscreteList_valid)),
+  0x11,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, geofenceIdDiscreteList),
+  QMI_LOC_MAX_GEOFENCE_ID_DISCRETE_LIST_LENGTH_V02,
+  QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, geofenceIdDiscreteList) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, geofenceIdDiscreteList_len),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, geofencePosition) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, geofencePosition_valid)),
+  0x12,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, geofencePosition),
+  QMI_IDL_TYPE88(0, 23),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, breachConfidence) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, breachConfidence_valid)),
+  0x13,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, breachConfidence),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, headingUnc) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, headingUnc_valid)),
+  0x14,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, headingUnc),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, vertUnc) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, vertUnc_valid)),
+  0x15,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, vertUnc),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, speedUnc) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, speedUnc_valid)),
+  0x16,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, speedUnc),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, horConfidence) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, horConfidence_valid)),
+  0x17,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, horConfidence),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, vertConfidence) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, vertConfidence_valid)),
+  0x18,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, vertConfidence),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, DOP) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, DOP_valid)),
+  0x19,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, DOP),
+  QMI_IDL_TYPE88(0, 2),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, gnssSvUsedList) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, gnssSvUsedList_valid)),
+  0x1A,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, gnssSvUsedList),
+  QMI_LOC_MAX_SV_USED_LIST_LENGTH_V02,
+  QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, gnssSvUsedList) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedBreachIndMsgT_v02, gnssSvUsedList_len)
+};
+
+static const uint8_t qmiLocEventGeofenceProximityIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGeofenceProximityIndMsgT_v02, proximityType),
+
+  0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGeofenceProximityIndMsgT_v02, geofenceId),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventGeofenceProximityIndMsgT_v02, contextId) - QMI_IDL_OFFSET8(qmiLocEventGeofenceProximityIndMsgT_v02, contextId_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGeofenceProximityIndMsgT_v02, contextId)
+};
+
+static const uint8_t qmiLocEventGeofenceBatchedDwellIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, dwellType),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, geofenceIdContinuousList) - QMI_IDL_OFFSET8(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, geofenceIdContinuousList_valid)),
+  0x10,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, geofenceIdContinuousList),
+  QMI_LOC_MAX_GEOFENCE_ID_CONTINUOUS_LIST_LENGTH_V02,
+  QMI_IDL_OFFSET8(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, geofenceIdContinuousList) - QMI_IDL_OFFSET8(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, geofenceIdContinuousList_len),
+  QMI_IDL_TYPE88(0, 24),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, geofenceIdDiscreteList) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, geofenceIdDiscreteList_valid)),
+  0x11,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, geofenceIdDiscreteList),
+  QMI_LOC_MAX_GEOFENCE_ID_DISCRETE_LIST_LENGTH_V02,
+  QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, geofenceIdDiscreteList) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, geofenceIdDiscreteList_len),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, geofencePosition) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, geofencePosition_valid)),
+  0x12,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, geofencePosition),
+  QMI_IDL_TYPE88(0, 23),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, headingUnc) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, headingUnc_valid)),
+  0x13,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, headingUnc),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, vertUnc) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, vertUnc_valid)),
+  0x14,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, vertUnc),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, speedUnc) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, speedUnc_valid)),
+  0x15,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, speedUnc),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, horConfidence) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, horConfidence_valid)),
+  0x16,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, horConfidence),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, vertConfidence) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, vertConfidence_valid)),
+  0x17,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, vertConfidence),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, DOP) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, DOP_valid)),
+  0x18,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, DOP),
+  QMI_IDL_TYPE88(0, 2),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, gnssSvUsedList) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, gnssSvUsedList_valid)),
+  0x19,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, gnssSvUsedList),
+  QMI_LOC_MAX_SV_USED_LIST_LENGTH_V02,
+  QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, gnssSvUsedList) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventGeofenceBatchedDwellIndMsgT_v02, gnssSvUsedList_len)
+};
+
+static const uint8_t qmiLocEventGdtUploadBeginStatusReqIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGdtUploadBeginStatusReqIndMsgT_v02, serviceId),
+
+  0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGdtUploadBeginStatusReqIndMsgT_v02, sessionId),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x03,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGdtUploadBeginStatusReqIndMsgT_v02, filePath),
+  QMI_LOC_MAX_GDT_PATH_LEN_V02,
+  QMI_IDL_OFFSET8(qmiLocEventGdtUploadBeginStatusReqIndMsgT_v02, filePath) - QMI_IDL_OFFSET8(qmiLocEventGdtUploadBeginStatusReqIndMsgT_v02, filePath_len)
+};
+
+static const uint8_t qmiLocEventGdtUploadEndReqIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGdtUploadEndReqIndMsgT_v02, serviceId),
+
+  0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGdtUploadEndReqIndMsgT_v02, sessionId),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x03,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGdtUploadEndReqIndMsgT_v02, endStatus)
+};
+
+static const uint8_t qmiLocEventGdtDownloadBeginReqIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGdtDownloadBeginReqIndMsgT_v02, serviceId),
+
+  0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGdtDownloadBeginReqIndMsgT_v02, sessionId),
+
+  0x03,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGdtDownloadBeginReqIndMsgT_v02, respTimeoutInterval),
+
+  0x04,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN | QMI_IDL_FLAGS_SZ_IS_16 |   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGdtDownloadBeginReqIndMsgT_v02, clientInfo),
+  ((QMI_LOC_MAX_GTP_CL_INFO_LEN_V02) & 0xFF), ((QMI_LOC_MAX_GTP_CL_INFO_LEN_V02) >> 8),
+  QMI_IDL_OFFSET8(qmiLocEventGdtDownloadBeginReqIndMsgT_v02, clientInfo) - QMI_IDL_OFFSET8(qmiLocEventGdtDownloadBeginReqIndMsgT_v02, clientInfo_len),
+
+  0x05,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN | QMI_IDL_FLAGS_SZ_IS_16 |   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventGdtDownloadBeginReqIndMsgT_v02, mobileStatusData),
+  ((QMI_LOC_MAX_GTP_MSD_LEN_V02) & 0xFF), ((QMI_LOC_MAX_GTP_MSD_LEN_V02) >> 8),
+  QMI_IDL_OFFSET16RELATIVE(qmiLocEventGdtDownloadBeginReqIndMsgT_v02, mobileStatusData) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventGdtDownloadBeginReqIndMsgT_v02, mobileStatusData_len),
+
+  0x06,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventGdtDownloadBeginReqIndMsgT_v02, filePath),
+  QMI_LOC_MAX_GDT_PATH_LEN_V02,
+  QMI_IDL_OFFSET16RELATIVE(qmiLocEventGdtDownloadBeginReqIndMsgT_v02, filePath) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventGdtDownloadBeginReqIndMsgT_v02, filePath_len),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventGdtDownloadBeginReqIndMsgT_v02, powerBudgetInfo) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventGdtDownloadBeginReqIndMsgT_v02, powerBudgetInfo_valid)),
+  0x10,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventGdtDownloadBeginReqIndMsgT_v02, powerBudgetInfo),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventGdtDownloadBeginReqIndMsgT_v02, powerBudgetAllowance) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventGdtDownloadBeginReqIndMsgT_v02, powerBudgetAllowance_valid)),
+  0x11,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventGdtDownloadBeginReqIndMsgT_v02, powerBudgetAllowance),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventGdtDownloadBeginReqIndMsgT_v02, downloadRequestMask) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventGdtDownloadBeginReqIndMsgT_v02, downloadRequestMask_valid)),
+  0x12,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventGdtDownloadBeginReqIndMsgT_v02, downloadRequestMask)
+};
+
+static const uint8_t qmiLocEventGdtReceiveDoneIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGdtReceiveDoneIndMsgT_v02, serviceId),
+
+  0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGdtReceiveDoneIndMsgT_v02, sessionId),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x03,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGdtReceiveDoneIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocEventGdtDownloadEndReqIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGdtDownloadEndReqIndMsgT_v02, serviceId),
+
+  0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGdtDownloadEndReqIndMsgT_v02, sessionId),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x03,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGdtDownloadEndReqIndMsgT_v02, status)
+};
+
+/*
+ * qmiLocGetServiceRevisionReqMsgT is empty
+ * static const uint8_t qmiLocGetServiceRevisionReqMsgT_data_v02[] = {
+ * };
+ */
+
+static const uint8_t qmiLocGetServiceRevisionIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetServiceRevisionIndMsgT_v02, status),
+
+  0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetServiceRevisionIndMsgT_v02, revision),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetServiceRevisionIndMsgT_v02, gnssMeFWVerString) - QMI_IDL_OFFSET8(qmiLocGetServiceRevisionIndMsgT_v02, gnssMeFWVerString_valid)),
+  0x10,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_STRING,
+  QMI_IDL_OFFSET8(qmiLocGetServiceRevisionIndMsgT_v02, gnssMeFWVerString),
+  QMI_LOC_GNSS_ME_VERSION_STRING_MAX_LENGTH_V02,
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetServiceRevisionIndMsgT_v02, gnssHostSWVerString) - QMI_IDL_OFFSET8(qmiLocGetServiceRevisionIndMsgT_v02, gnssHostSWVerString_valid)),
+  0x11,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_STRING,
+  QMI_IDL_OFFSET8(qmiLocGetServiceRevisionIndMsgT_v02, gnssHostSWVerString),
+  QMI_LOC_GNSS_HOSTED_SW_VERSION_STRING_MAX_LENGTH_V02,
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocGetServiceRevisionIndMsgT_v02, gnssSWVerString) - QMI_IDL_OFFSET16RELATIVE(qmiLocGetServiceRevisionIndMsgT_v02, gnssSWVerString_valid)),
+  0x12,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_STRING,
+  QMI_IDL_OFFSET16ARRAY(qmiLocGetServiceRevisionIndMsgT_v02, gnssSWVerString),
+  QMI_LOC_GNSS_SW_VERSION_STRING_MAX_LENGTH_V02
+};
+
+/*
+ * qmiLocGetFixCriteriaReqMsgT is empty
+ * static const uint8_t qmiLocGetFixCriteriaReqMsgT_data_v02[] = {
+ * };
+ */
+
+static const uint8_t qmiLocGetFixCriteriaIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetFixCriteriaIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetFixCriteriaIndMsgT_v02, horizontalAccuracyLevel) - QMI_IDL_OFFSET8(qmiLocGetFixCriteriaIndMsgT_v02, horizontalAccuracyLevel_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetFixCriteriaIndMsgT_v02, horizontalAccuracyLevel),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetFixCriteriaIndMsgT_v02, intermediateReportState) - QMI_IDL_OFFSET8(qmiLocGetFixCriteriaIndMsgT_v02, intermediateReportState_valid)),
+  0x11,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetFixCriteriaIndMsgT_v02, intermediateReportState),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetFixCriteriaIndMsgT_v02, minInterval) - QMI_IDL_OFFSET8(qmiLocGetFixCriteriaIndMsgT_v02, minInterval_valid)),
+  0x12,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetFixCriteriaIndMsgT_v02, minInterval),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetFixCriteriaIndMsgT_v02, applicationId) - QMI_IDL_OFFSET8(qmiLocGetFixCriteriaIndMsgT_v02, applicationId_valid)),
+  0x13,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocGetFixCriteriaIndMsgT_v02, applicationId),
+  QMI_IDL_TYPE88(0, 0),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetFixCriteriaIndMsgT_v02, configAltitudeAssumed) - QMI_IDL_OFFSET8(qmiLocGetFixCriteriaIndMsgT_v02, configAltitudeAssumed_valid)),
+  0x14,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetFixCriteriaIndMsgT_v02, configAltitudeAssumed),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetFixCriteriaIndMsgT_v02, minIntermediatePositionReportInterval) - QMI_IDL_OFFSET8(qmiLocGetFixCriteriaIndMsgT_v02, minIntermediatePositionReportInterval_valid)),
+  0x15,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetFixCriteriaIndMsgT_v02, minIntermediatePositionReportInterval),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetFixCriteriaIndMsgT_v02, positionReportTimeout) - QMI_IDL_OFFSET8(qmiLocGetFixCriteriaIndMsgT_v02, positionReportTimeout_valid)),
+  0x16,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetFixCriteriaIndMsgT_v02, positionReportTimeout),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetFixCriteriaIndMsgT_v02, sharePosition) - QMI_IDL_OFFSET8(qmiLocGetFixCriteriaIndMsgT_v02, sharePosition_valid)),
+  0x17,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetFixCriteriaIndMsgT_v02, sharePosition)
+};
+
+static const uint8_t qmiLocNiUserRespReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNiUserRespReqMsgT_v02, userResp),
+
+  0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNiUserRespReqMsgT_v02, notificationType),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocNiUserRespReqMsgT_v02, NiVxPayload) - QMI_IDL_OFFSET8(qmiLocNiUserRespReqMsgT_v02, NiVxPayload_valid)),
+  0x10,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocNiUserRespReqMsgT_v02, NiVxPayload),
+  QMI_IDL_TYPE88(0, 5),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocNiUserRespReqMsgT_v02, NiSuplPayload) - QMI_IDL_OFFSET16RELATIVE(qmiLocNiUserRespReqMsgT_v02, NiSuplPayload_valid)),
+  0x11,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocNiUserRespReqMsgT_v02, NiSuplPayload),
+  QMI_IDL_TYPE88(0, 11),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocNiUserRespReqMsgT_v02, NiUmtsCpPayload) - QMI_IDL_OFFSET16RELATIVE(qmiLocNiUserRespReqMsgT_v02, NiUmtsCpPayload_valid)),
+  0x12,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocNiUserRespReqMsgT_v02, NiUmtsCpPayload),
+  QMI_IDL_TYPE88(0, 13),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocNiUserRespReqMsgT_v02, NiVxServiceInteractionPayload) - QMI_IDL_OFFSET16RELATIVE(qmiLocNiUserRespReqMsgT_v02, NiVxServiceInteractionPayload_valid)),
+  0x13,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocNiUserRespReqMsgT_v02, NiVxServiceInteractionPayload),
+  QMI_IDL_TYPE88(0, 14),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocNiUserRespReqMsgT_v02, NiSuplVer2ExtPayload) - QMI_IDL_OFFSET16RELATIVE(qmiLocNiUserRespReqMsgT_v02, NiSuplVer2ExtPayload_valid)),
+  0x14,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocNiUserRespReqMsgT_v02, NiSuplVer2ExtPayload),
+  QMI_IDL_TYPE88(0, 15),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocNiUserRespReqMsgT_v02, suplEmergencyNotification) - QMI_IDL_OFFSET16RELATIVE(qmiLocNiUserRespReqMsgT_v02, suplEmergencyNotification_valid)),
+  0x15,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocNiUserRespReqMsgT_v02, suplEmergencyNotification),
+  QMI_IDL_TYPE88(0, 16)
+};
+
+static const uint8_t qmiLocNiUserRespIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNiUserRespIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocInjectPredictedOrbitsDataReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectPredictedOrbitsDataReqMsgT_v02, totalSize),
+
+  0x02,
+   QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectPredictedOrbitsDataReqMsgT_v02, totalParts),
+
+  0x03,
+   QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectPredictedOrbitsDataReqMsgT_v02, partNum),
+
+  0x04,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN | QMI_IDL_FLAGS_SZ_IS_16 |   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectPredictedOrbitsDataReqMsgT_v02, partData),
+  ((QMI_LOC_MAX_PREDICTED_ORBITS_PART_LEN_V02) & 0xFF), ((QMI_LOC_MAX_PREDICTED_ORBITS_PART_LEN_V02) >> 8),
+  QMI_IDL_OFFSET8(qmiLocInjectPredictedOrbitsDataReqMsgT_v02, partData) - QMI_IDL_OFFSET8(qmiLocInjectPredictedOrbitsDataReqMsgT_v02, partData_len),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocInjectPredictedOrbitsDataReqMsgT_v02, formatType) - QMI_IDL_OFFSET16RELATIVE(qmiLocInjectPredictedOrbitsDataReqMsgT_v02, formatType_valid)),
+  0x10,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocInjectPredictedOrbitsDataReqMsgT_v02, formatType)
+};
+
+static const uint8_t qmiLocInjectPredictedOrbitsDataIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectPredictedOrbitsDataIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectPredictedOrbitsDataIndMsgT_v02, partNum) - QMI_IDL_OFFSET8(qmiLocInjectPredictedOrbitsDataIndMsgT_v02, partNum_valid)),
+  0x10,
+   QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectPredictedOrbitsDataIndMsgT_v02, partNum)
+};
+
+/*
+ * qmiLocGetPredictedOrbitsDataSourceReqMsgT is empty
+ * static const uint8_t qmiLocGetPredictedOrbitsDataSourceReqMsgT_data_v02[] = {
+ * };
+ */
+
+static const uint8_t qmiLocGetPredictedOrbitsDataSourceIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetPredictedOrbitsDataSourceIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetPredictedOrbitsDataSourceIndMsgT_v02, allowedSizes) - QMI_IDL_OFFSET8(qmiLocGetPredictedOrbitsDataSourceIndMsgT_v02, allowedSizes_valid)),
+  0x10,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocGetPredictedOrbitsDataSourceIndMsgT_v02, allowedSizes),
+  QMI_IDL_TYPE88(0, 19),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetPredictedOrbitsDataSourceIndMsgT_v02, serverList) - QMI_IDL_OFFSET8(qmiLocGetPredictedOrbitsDataSourceIndMsgT_v02, serverList_valid)),
+  0x11,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocGetPredictedOrbitsDataSourceIndMsgT_v02, serverList),
+  QMI_IDL_TYPE88(0, 20)
+};
+
+/*
+ * qmiLocGetPredictedOrbitsDataValidityReqMsgT is empty
+ * static const uint8_t qmiLocGetPredictedOrbitsDataValidityReqMsgT_data_v02[] = {
+ * };
+ */
+
+static const uint8_t qmiLocGetPredictedOrbitsDataValidityIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetPredictedOrbitsDataValidityIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetPredictedOrbitsDataValidityIndMsgT_v02, validityInfo) - QMI_IDL_OFFSET8(qmiLocGetPredictedOrbitsDataValidityIndMsgT_v02, validityInfo_valid)),
+  0x10,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocGetPredictedOrbitsDataValidityIndMsgT_v02, validityInfo),
+  QMI_IDL_TYPE88(0, 25)
+};
+
+static const uint8_t qmiLocInjectUtcTimeReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectUtcTimeReqMsgT_v02, timeUtc),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectUtcTimeReqMsgT_v02, timeUnc)
+};
+
+static const uint8_t qmiLocInjectUtcTimeIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectUtcTimeIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocInjectPositionReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, latitude) - QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, latitude_valid)),
+  0x10,
+   QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, latitude),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, longitude) - QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, longitude_valid)),
+  0x11,
+   QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, longitude),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, horUncCircular) - QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, horUncCircular_valid)),
+  0x12,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, horUncCircular),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, horConfidence) - QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, horConfidence_valid)),
+  0x13,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, horConfidence),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, horReliability) - QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, horReliability_valid)),
+  0x14,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, horReliability),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, altitudeWrtEllipsoid) - QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, altitudeWrtEllipsoid_valid)),
+  0x15,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, altitudeWrtEllipsoid),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, altitudeWrtMeanSeaLevel) - QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, altitudeWrtMeanSeaLevel_valid)),
+  0x16,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, altitudeWrtMeanSeaLevel),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, vertUnc) - QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, vertUnc_valid)),
+  0x17,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, vertUnc),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, vertConfidence) - QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, vertConfidence_valid)),
+  0x18,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, vertConfidence),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, vertReliability) - QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, vertReliability_valid)),
+  0x19,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, vertReliability),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, altSourceInfo) - QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, altSourceInfo_valid)),
+  0x1A,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, altSourceInfo),
+  QMI_IDL_TYPE88(0, 26),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, timestampUtc) - QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, timestampUtc_valid)),
+  0x1B,
+   QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, timestampUtc),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, timestampAge) - QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, timestampAge_valid)),
+  0x1C,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, timestampAge),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, positionSrc) - QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, positionSrc_valid)),
+  0x1D,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, positionSrc),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, rawHorUncCircular) - QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, rawHorUncCircular_valid)),
+  0x1E,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, rawHorUncCircular),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, rawHorConfidence) - QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, rawHorConfidence_valid)),
+  0x1F,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, rawHorConfidence),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, onDemandCpi) - QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, onDemandCpi_valid)),
+  0x20,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectPositionReqMsgT_v02, onDemandCpi)
+};
+
+static const uint8_t qmiLocInjectPositionIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectPositionIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocSetEngineLockReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetEngineLockReqMsgT_v02, lockType)
+};
+
+static const uint8_t qmiLocSetEngineLockIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetEngineLockIndMsgT_v02, status)
+};
+
+/*
+ * qmiLocGetEngineLockReqMsgT is empty
+ * static const uint8_t qmiLocGetEngineLockReqMsgT_data_v02[] = {
+ * };
+ */
+
+static const uint8_t qmiLocGetEngineLockIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetEngineLockIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetEngineLockIndMsgT_v02, lockType) - QMI_IDL_OFFSET8(qmiLocGetEngineLockIndMsgT_v02, lockType_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetEngineLockIndMsgT_v02, lockType)
+};
+
+static const uint8_t qmiLocSetSbasConfigReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetSbasConfigReqMsgT_v02, sbasConfig)
+};
+
+static const uint8_t qmiLocSetSbasConfigIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetSbasConfigIndMsgT_v02, status)
+};
+
+/*
+ * qmiLocGetSbasConfigReqMsgT is empty
+ * static const uint8_t qmiLocGetSbasConfigReqMsgT_data_v02[] = {
+ * };
+ */
+
+static const uint8_t qmiLocGetSbasConfigIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetSbasConfigIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetSbasConfigIndMsgT_v02, sbasConfig) - QMI_IDL_OFFSET8(qmiLocGetSbasConfigIndMsgT_v02, sbasConfig_valid)),
+  0x10,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetSbasConfigIndMsgT_v02, sbasConfig)
+};
+
+static const uint8_t qmiLocSetNmeaTypesReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetNmeaTypesReqMsgT_v02, nmeaSentenceType)
+};
+
+static const uint8_t qmiLocSetNmeaTypesIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetNmeaTypesIndMsgT_v02, status)
+};
+
+/*
+ * qmiLocGetNmeaTypesReqMsgT is empty
+ * static const uint8_t qmiLocGetNmeaTypesReqMsgT_data_v02[] = {
+ * };
+ */
+
+static const uint8_t qmiLocGetNmeaTypesIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetNmeaTypesIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetNmeaTypesIndMsgT_v02, nmeaSentenceType) - QMI_IDL_OFFSET8(qmiLocGetNmeaTypesIndMsgT_v02, nmeaSentenceType_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetNmeaTypesIndMsgT_v02, nmeaSentenceType)
+};
+
+static const uint8_t qmiLocSetLowPowerModeReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetLowPowerModeReqMsgT_v02, lowPowerMode)
+};
+
+static const uint8_t qmiLocSetLowPowerModeIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetLowPowerModeIndMsgT_v02, status)
+};
+
+/*
+ * qmiLocGetLowPowerModeReqMsgT is empty
+ * static const uint8_t qmiLocGetLowPowerModeReqMsgT_data_v02[] = {
+ * };
+ */
+
+static const uint8_t qmiLocGetLowPowerModeIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetLowPowerModeIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetLowPowerModeIndMsgT_v02, lowPowerMode) - QMI_IDL_OFFSET8(qmiLocGetLowPowerModeIndMsgT_v02, lowPowerMode_valid)),
+  0x10,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetLowPowerModeIndMsgT_v02, lowPowerMode)
+};
+
+static const uint8_t qmiLocSetServerReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetServerReqMsgT_v02, serverType),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetServerReqMsgT_v02, ipv4Addr) - QMI_IDL_OFFSET8(qmiLocSetServerReqMsgT_v02, ipv4Addr_valid)),
+  0x10,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocSetServerReqMsgT_v02, ipv4Addr),
+  QMI_IDL_TYPE88(0, 8),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetServerReqMsgT_v02, ipv6Addr) - QMI_IDL_OFFSET8(qmiLocSetServerReqMsgT_v02, ipv6Addr_valid)),
+  0x11,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocSetServerReqMsgT_v02, ipv6Addr),
+  QMI_IDL_TYPE88(0, 9),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetServerReqMsgT_v02, urlAddr) - QMI_IDL_OFFSET8(qmiLocSetServerReqMsgT_v02, urlAddr_valid)),
+  0x12,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_STRING,
+  QMI_IDL_OFFSET8(qmiLocSetServerReqMsgT_v02, urlAddr),
+  QMI_LOC_MAX_SERVER_ADDR_LENGTH_V02
+};
+
+static const uint8_t qmiLocSetServerIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetServerIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocGetServerReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetServerReqMsgT_v02, serverType),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetServerReqMsgT_v02, serverAddrTypeMask) - QMI_IDL_OFFSET8(qmiLocGetServerReqMsgT_v02, serverAddrTypeMask_valid)),
+  0x10,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetServerReqMsgT_v02, serverAddrTypeMask)
+};
+
+static const uint8_t qmiLocGetServerIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetServerIndMsgT_v02, status),
+
+  0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetServerIndMsgT_v02, serverType),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetServerIndMsgT_v02, ipv4Addr) - QMI_IDL_OFFSET8(qmiLocGetServerIndMsgT_v02, ipv4Addr_valid)),
+  0x10,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocGetServerIndMsgT_v02, ipv4Addr),
+  QMI_IDL_TYPE88(0, 8),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetServerIndMsgT_v02, ipv6Addr) - QMI_IDL_OFFSET8(qmiLocGetServerIndMsgT_v02, ipv6Addr_valid)),
+  0x11,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocGetServerIndMsgT_v02, ipv6Addr),
+  QMI_IDL_TYPE88(0, 9),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetServerIndMsgT_v02, urlAddr) - QMI_IDL_OFFSET8(qmiLocGetServerIndMsgT_v02, urlAddr_valid)),
+  0x12,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_STRING,
+  QMI_IDL_OFFSET8(qmiLocGetServerIndMsgT_v02, urlAddr),
+  QMI_LOC_MAX_SERVER_ADDR_LENGTH_V02
+};
+
+static const uint8_t qmiLocDeleteAssistDataReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDeleteAssistDataReqMsgT_v02, deleteAllFlag),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocDeleteAssistDataReqMsgT_v02, deleteSvInfoList) - QMI_IDL_OFFSET8(qmiLocDeleteAssistDataReqMsgT_v02, deleteSvInfoList_valid)),
+  0x10,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocDeleteAssistDataReqMsgT_v02, deleteSvInfoList),
+  QMI_LOC_DELETE_MAX_SV_INFO_LENGTH_V02,
+  QMI_IDL_OFFSET8(qmiLocDeleteAssistDataReqMsgT_v02, deleteSvInfoList) - QMI_IDL_OFFSET8(qmiLocDeleteAssistDataReqMsgT_v02, deleteSvInfoList_len),
+  QMI_IDL_TYPE88(0, 27),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocDeleteAssistDataReqMsgT_v02, deleteGnssDataMask) - QMI_IDL_OFFSET16RELATIVE(qmiLocDeleteAssistDataReqMsgT_v02, deleteGnssDataMask_valid)),
+  0x11,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocDeleteAssistDataReqMsgT_v02, deleteGnssDataMask),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocDeleteAssistDataReqMsgT_v02, deleteCellDbDataMask) - QMI_IDL_OFFSET16RELATIVE(qmiLocDeleteAssistDataReqMsgT_v02, deleteCellDbDataMask_valid)),
+  0x12,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocDeleteAssistDataReqMsgT_v02, deleteCellDbDataMask),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocDeleteAssistDataReqMsgT_v02, deleteClockInfoMask) - QMI_IDL_OFFSET16RELATIVE(qmiLocDeleteAssistDataReqMsgT_v02, deleteClockInfoMask_valid)),
+  0x13,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocDeleteAssistDataReqMsgT_v02, deleteClockInfoMask),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocDeleteAssistDataReqMsgT_v02, deleteBdsSvInfoList) - QMI_IDL_OFFSET16RELATIVE(qmiLocDeleteAssistDataReqMsgT_v02, deleteBdsSvInfoList_valid)),
+  0x14,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocDeleteAssistDataReqMsgT_v02, deleteBdsSvInfoList),
+  QMI_LOC_DELETE_MAX_BDS_SV_INFO_LENGTH_V02,
+  QMI_IDL_OFFSET16RELATIVE(qmiLocDeleteAssistDataReqMsgT_v02, deleteBdsSvInfoList) - QMI_IDL_OFFSET16RELATIVE(qmiLocDeleteAssistDataReqMsgT_v02, deleteBdsSvInfoList_len),
+  QMI_IDL_TYPE88(0, 28),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocDeleteAssistDataReqMsgT_v02, deleteGalSvInfoList) - QMI_IDL_OFFSET16RELATIVE(qmiLocDeleteAssistDataReqMsgT_v02, deleteGalSvInfoList_valid)),
+  0x15,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocDeleteAssistDataReqMsgT_v02, deleteGalSvInfoList),
+  QMI_LOC_DELETE_MAX_GAL_SV_INFO_LENGTH_V02,
+  QMI_IDL_OFFSET16RELATIVE(qmiLocDeleteAssistDataReqMsgT_v02, deleteGalSvInfoList) - QMI_IDL_OFFSET16RELATIVE(qmiLocDeleteAssistDataReqMsgT_v02, deleteGalSvInfoList_len),
+  QMI_IDL_TYPE88(0, 29)
+};
+
+static const uint8_t qmiLocDeleteAssistDataIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDeleteAssistDataIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocSetXtraTSessionControlReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetXtraTSessionControlReqMsgT_v02, xtraTSessionControl)
+};
+
+static const uint8_t qmiLocSetXtraTSessionControlIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetXtraTSessionControlIndMsgT_v02, status)
+};
+
+/*
+ * qmiLocGetXtraTSessionControlReqMsgT is empty
+ * static const uint8_t qmiLocGetXtraTSessionControlReqMsgT_data_v02[] = {
+ * };
+ */
+
+static const uint8_t qmiLocGetXtraTSessionControlIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetXtraTSessionControlIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetXtraTSessionControlIndMsgT_v02, xtraTSessionControl) - QMI_IDL_OFFSET8(qmiLocGetXtraTSessionControlIndMsgT_v02, xtraTSessionControl_valid)),
+  0x10,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetXtraTSessionControlIndMsgT_v02, xtraTSessionControl)
+};
+
+static const uint8_t qmiLocInjectWifiPositionReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectWifiPositionReqMsgT_v02, wifiFixTime) - QMI_IDL_OFFSET8(qmiLocInjectWifiPositionReqMsgT_v02, wifiFixTime_valid)),
+  0x10,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocInjectWifiPositionReqMsgT_v02, wifiFixTime),
+  QMI_IDL_TYPE88(0, 30),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectWifiPositionReqMsgT_v02, wifiFixPosition) - QMI_IDL_OFFSET8(qmiLocInjectWifiPositionReqMsgT_v02, wifiFixPosition_valid)),
+  0x11,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocInjectWifiPositionReqMsgT_v02, wifiFixPosition),
+  QMI_IDL_TYPE88(0, 31),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectWifiPositionReqMsgT_v02, apInfo) - QMI_IDL_OFFSET8(qmiLocInjectWifiPositionReqMsgT_v02, apInfo_valid)),
+  0x12,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocInjectWifiPositionReqMsgT_v02, apInfo),
+  QMI_LOC_WIFI_MAX_REPORTED_APS_PER_MSG_V02,
+  QMI_IDL_OFFSET8(qmiLocInjectWifiPositionReqMsgT_v02, apInfo) - QMI_IDL_OFFSET8(qmiLocInjectWifiPositionReqMsgT_v02, apInfo_len),
+  QMI_IDL_TYPE88(0, 32),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocInjectWifiPositionReqMsgT_v02, horizontalReliability) - QMI_IDL_OFFSET16RELATIVE(qmiLocInjectWifiPositionReqMsgT_v02, horizontalReliability_valid)),
+  0x13,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocInjectWifiPositionReqMsgT_v02, horizontalReliability),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocInjectWifiPositionReqMsgT_v02, rawHepe) - QMI_IDL_OFFSET16RELATIVE(qmiLocInjectWifiPositionReqMsgT_v02, rawHepe_valid)),
+  0x14,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocInjectWifiPositionReqMsgT_v02, rawHepe),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocInjectWifiPositionReqMsgT_v02, wifiApSsidInfo) - QMI_IDL_OFFSET16RELATIVE(qmiLocInjectWifiPositionReqMsgT_v02, wifiApSsidInfo_valid)),
+  0x15,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocInjectWifiPositionReqMsgT_v02, wifiApSsidInfo),
+  QMI_LOC_WIFI_MAX_REPORTED_APS_PER_MSG_V02,
+  QMI_IDL_OFFSET16RELATIVE(qmiLocInjectWifiPositionReqMsgT_v02, wifiApSsidInfo) - QMI_IDL_OFFSET16RELATIVE(qmiLocInjectWifiPositionReqMsgT_v02, wifiApSsidInfo_len),
+  QMI_IDL_TYPE88(0, 33)
+};
+
+static const uint8_t qmiLocInjectWifiPositionIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectWifiPositionIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocNotifyWifiStatusReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNotifyWifiStatusReqMsgT_v02, wifiStatus)
+};
+
+static const uint8_t qmiLocNotifyWifiStatusIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNotifyWifiStatusIndMsgT_v02, status)
+};
+
+/*
+ * qmiLocGetRegisteredEventsReqMsgT is empty
+ * static const uint8_t qmiLocGetRegisteredEventsReqMsgT_data_v02[] = {
+ * };
+ */
+
+static const uint8_t qmiLocGetRegisteredEventsIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetRegisteredEventsIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetRegisteredEventsIndMsgT_v02, eventRegMask) - QMI_IDL_OFFSET8(qmiLocGetRegisteredEventsIndMsgT_v02, eventRegMask_valid)),
+  0x10,
+   QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetRegisteredEventsIndMsgT_v02, eventRegMask)
+};
+
+static const uint8_t qmiLocSetOperationModeReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetOperationModeReqMsgT_v02, operationMode),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetOperationModeReqMsgT_v02, minInterval) - QMI_IDL_OFFSET8(qmiLocSetOperationModeReqMsgT_v02, minInterval_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetOperationModeReqMsgT_v02, minInterval)
+};
+
+static const uint8_t qmiLocSetOperationModeIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetOperationModeIndMsgT_v02, status)
+};
+
+/*
+ * qmiLocGetOperationModeReqMsgT is empty
+ * static const uint8_t qmiLocGetOperationModeReqMsgT_data_v02[] = {
+ * };
+ */
+
+static const uint8_t qmiLocGetOperationModeIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetOperationModeIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetOperationModeIndMsgT_v02, operationMode) - QMI_IDL_OFFSET8(qmiLocGetOperationModeIndMsgT_v02, operationMode_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetOperationModeIndMsgT_v02, operationMode)
+};
+
+static const uint8_t qmiLocSetSpiStatusReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetSpiStatusReqMsgT_v02, stationary),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetSpiStatusReqMsgT_v02, confidenceStationary) - QMI_IDL_OFFSET8(qmiLocSetSpiStatusReqMsgT_v02, confidenceStationary_valid)),
+  0x10,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetSpiStatusReqMsgT_v02, confidenceStationary)
+};
+
+static const uint8_t qmiLocSetSpiStatusIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetSpiStatusIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocInjectSensorDataReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectSensorDataReqMsgT_v02, opaqueIdentifier) - QMI_IDL_OFFSET8(qmiLocInjectSensorDataReqMsgT_v02, opaqueIdentifier_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectSensorDataReqMsgT_v02, opaqueIdentifier),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectSensorDataReqMsgT_v02, threeAxisAccelData) - QMI_IDL_OFFSET8(qmiLocInjectSensorDataReqMsgT_v02, threeAxisAccelData_valid)),
+  0x11,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocInjectSensorDataReqMsgT_v02, threeAxisAccelData),
+  QMI_IDL_TYPE88(0, 35),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocInjectSensorDataReqMsgT_v02, threeAxisGyroData) - QMI_IDL_OFFSET16RELATIVE(qmiLocInjectSensorDataReqMsgT_v02, threeAxisGyroData_valid)),
+  0x12,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocInjectSensorDataReqMsgT_v02, threeAxisGyroData),
+  QMI_IDL_TYPE88(0, 35),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocInjectSensorDataReqMsgT_v02, threeAxisAccelDataTimeSource) - QMI_IDL_OFFSET16RELATIVE(qmiLocInjectSensorDataReqMsgT_v02, threeAxisAccelDataTimeSource_valid)),
+  0x13,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocInjectSensorDataReqMsgT_v02, threeAxisAccelDataTimeSource),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocInjectSensorDataReqMsgT_v02, threeAxisGyroDataTimeSource) - QMI_IDL_OFFSET16RELATIVE(qmiLocInjectSensorDataReqMsgT_v02, threeAxisGyroDataTimeSource_valid)),
+  0x14,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocInjectSensorDataReqMsgT_v02, threeAxisGyroDataTimeSource),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocInjectSensorDataReqMsgT_v02, accelTemperatureData) - QMI_IDL_OFFSET16RELATIVE(qmiLocInjectSensorDataReqMsgT_v02, accelTemperatureData_valid)),
+  0x15,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocInjectSensorDataReqMsgT_v02, accelTemperatureData),
+  QMI_IDL_TYPE88(0, 37),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocInjectSensorDataReqMsgT_v02, gyroTemperatureData) - QMI_IDL_OFFSET16RELATIVE(qmiLocInjectSensorDataReqMsgT_v02, gyroTemperatureData_valid)),
+  0x16,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocInjectSensorDataReqMsgT_v02, gyroTemperatureData),
+  QMI_IDL_TYPE88(0, 37),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocInjectSensorDataReqMsgT_v02, threeAxisMagData) - QMI_IDL_OFFSET16RELATIVE(qmiLocInjectSensorDataReqMsgT_v02, threeAxisMagData_valid)),
+  0x17,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocInjectSensorDataReqMsgT_v02, threeAxisMagData),
+  QMI_IDL_TYPE88(0, 35),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocInjectSensorDataReqMsgT_v02, threeAxisMagDataTimeSource) - QMI_IDL_OFFSET16RELATIVE(qmiLocInjectSensorDataReqMsgT_v02, threeAxisMagDataTimeSource_valid)),
+  0x18,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocInjectSensorDataReqMsgT_v02, threeAxisMagDataTimeSource)
+};
+
+static const uint8_t qmiLocInjectSensorDataIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectSensorDataIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectSensorDataIndMsgT_v02, opaqueIdentifier) - QMI_IDL_OFFSET8(qmiLocInjectSensorDataIndMsgT_v02, opaqueIdentifier_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectSensorDataIndMsgT_v02, opaqueIdentifier),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectSensorDataIndMsgT_v02, threeAxisAccelSamplesAccepted) - QMI_IDL_OFFSET8(qmiLocInjectSensorDataIndMsgT_v02, threeAxisAccelSamplesAccepted_valid)),
+  0x11,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectSensorDataIndMsgT_v02, threeAxisAccelSamplesAccepted),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectSensorDataIndMsgT_v02, threeAxisGyroSamplesAccepted) - QMI_IDL_OFFSET8(qmiLocInjectSensorDataIndMsgT_v02, threeAxisGyroSamplesAccepted_valid)),
+  0x12,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectSensorDataIndMsgT_v02, threeAxisGyroSamplesAccepted),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectSensorDataIndMsgT_v02, accelTemperatureSamplesAccepted) - QMI_IDL_OFFSET8(qmiLocInjectSensorDataIndMsgT_v02, accelTemperatureSamplesAccepted_valid)),
+  0x13,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectSensorDataIndMsgT_v02, accelTemperatureSamplesAccepted),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectSensorDataIndMsgT_v02, gyroTemperatureSamplesAccepted) - QMI_IDL_OFFSET8(qmiLocInjectSensorDataIndMsgT_v02, gyroTemperatureSamplesAccepted_valid)),
+  0x14,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectSensorDataIndMsgT_v02, gyroTemperatureSamplesAccepted),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectSensorDataIndMsgT_v02, threeAxisMagSamplesAccepted) - QMI_IDL_OFFSET8(qmiLocInjectSensorDataIndMsgT_v02, threeAxisMagSamplesAccepted_valid)),
+  0x15,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectSensorDataIndMsgT_v02, threeAxisMagSamplesAccepted)
+};
+
+static const uint8_t qmiLocInjectTimeSyncDataReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectTimeSyncDataReqMsgT_v02, refCounter),
+
+  0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectTimeSyncDataReqMsgT_v02, sensorProcRxTime),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x03,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectTimeSyncDataReqMsgT_v02, sensorProcTxTime)
+};
+
+static const uint8_t qmiLocInjectTimeSyncDataIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectTimeSyncDataIndMsgT_v02, status)
+};
+
+/*
+ * qmiLocGetCradleMountConfigReqMsgT is empty
+ * static const uint8_t qmiLocGetCradleMountConfigReqMsgT_data_v02[] = {
+ * };
+ */
+
+static const uint8_t qmiLocGetCradleMountConfigIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetCradleMountConfigIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetCradleMountConfigIndMsgT_v02, cradleMountState) - QMI_IDL_OFFSET8(qmiLocGetCradleMountConfigIndMsgT_v02, cradleMountState_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetCradleMountConfigIndMsgT_v02, cradleMountState),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetCradleMountConfigIndMsgT_v02, confidenceCradleMountState) - QMI_IDL_OFFSET8(qmiLocGetCradleMountConfigIndMsgT_v02, confidenceCradleMountState_valid)),
+  0x11,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetCradleMountConfigIndMsgT_v02, confidenceCradleMountState)
+};
+
+static const uint8_t qmiLocSetCradleMountConfigReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetCradleMountConfigReqMsgT_v02, cradleMountState),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetCradleMountConfigReqMsgT_v02, confidenceCradleMountState) - QMI_IDL_OFFSET8(qmiLocSetCradleMountConfigReqMsgT_v02, confidenceCradleMountState_valid)),
+  0x10,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetCradleMountConfigReqMsgT_v02, confidenceCradleMountState)
+};
+
+static const uint8_t qmiLocSetCradleMountConfigIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetCradleMountConfigIndMsgT_v02, status)
+};
+
+/*
+ * qmiLocGetExternalPowerConfigReqMsgT is empty
+ * static const uint8_t qmiLocGetExternalPowerConfigReqMsgT_data_v02[] = {
+ * };
+ */
+
+static const uint8_t qmiLocGetExternalPowerConfigIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetExternalPowerConfigIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetExternalPowerConfigIndMsgT_v02, externalPowerState) - QMI_IDL_OFFSET8(qmiLocGetExternalPowerConfigIndMsgT_v02, externalPowerState_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetExternalPowerConfigIndMsgT_v02, externalPowerState)
+};
+
+static const uint8_t qmiLocSetExternalPowerConfigReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetExternalPowerConfigReqMsgT_v02, externalPowerState)
+};
+
+static const uint8_t qmiLocSetExternalPowerConfigIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetExternalPowerConfigIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocInformLocationServerConnStatusReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInformLocationServerConnStatusReqMsgT_v02, connHandle),
+
+  0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInformLocationServerConnStatusReqMsgT_v02, requestType),
+
+  0x03,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInformLocationServerConnStatusReqMsgT_v02, statusType),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInformLocationServerConnStatusReqMsgT_v02, apnProfile) - QMI_IDL_OFFSET8(qmiLocInformLocationServerConnStatusReqMsgT_v02, apnProfile_valid)),
+  0x10,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocInformLocationServerConnStatusReqMsgT_v02, apnProfile),
+  QMI_IDL_TYPE88(0, 38)
+};
+
+static const uint8_t qmiLocInformLocationServerConnStatusIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInformLocationServerConnStatusIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocSetProtocolConfigParametersReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersReqMsgT_v02, suplSecurity) - QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersReqMsgT_v02, suplSecurity_valid)),
+  0x10,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersReqMsgT_v02, suplSecurity),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersReqMsgT_v02, vxVersion) - QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersReqMsgT_v02, vxVersion_valid)),
+  0x11,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersReqMsgT_v02, vxVersion),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersReqMsgT_v02, suplVersion) - QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersReqMsgT_v02, suplVersion_valid)),
+  0x12,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersReqMsgT_v02, suplVersion),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersReqMsgT_v02, lppConfig) - QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersReqMsgT_v02, lppConfig_valid)),
+  0x13,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersReqMsgT_v02, lppConfig),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersReqMsgT_v02, assistedGlonassProtocolMask) - QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersReqMsgT_v02, assistedGlonassProtocolMask_valid)),
+  0x14,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersReqMsgT_v02, assistedGlonassProtocolMask),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersReqMsgT_v02, suplHashAlgo) - QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersReqMsgT_v02, suplHashAlgo_valid)),
+  0x15,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersReqMsgT_v02, suplHashAlgo),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersReqMsgT_v02, suplTlsVersion) - QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersReqMsgT_v02, suplTlsVersion_valid)),
+  0x16,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersReqMsgT_v02, suplTlsVersion),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersReqMsgT_v02, emergencyProtocol) - QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersReqMsgT_v02, emergencyProtocol_valid)),
+  0x17,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersReqMsgT_v02, emergencyProtocol),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersReqMsgT_v02, wifiScanInjectTimeout) - QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersReqMsgT_v02, wifiScanInjectTimeout_valid)),
+  0x18,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersReqMsgT_v02, wifiScanInjectTimeout),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersReqMsgT_v02, lppeUpConfig) - QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersReqMsgT_v02, lppeUpConfig_valid)),
+  0x19,
+   QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersReqMsgT_v02, lppeUpConfig),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersReqMsgT_v02, lppeCpConfig) - QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersReqMsgT_v02, lppeCpConfig_valid)),
+  0x1A,
+   QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersReqMsgT_v02, lppeCpConfig)
+};
+
+static const uint8_t qmiLocSetProtocolConfigParametersIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersIndMsgT_v02, failedProtocolConfigParamMask) - QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersIndMsgT_v02, failedProtocolConfigParamMask_valid)),
+  0x10,
+   QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetProtocolConfigParametersIndMsgT_v02, failedProtocolConfigParamMask)
+};
+
+static const uint8_t qmiLocGetProtocolConfigParametersReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetProtocolConfigParametersReqMsgT_v02, getProtocolConfigParamMask)
+};
+
+static const uint8_t qmiLocGetProtocolConfigParametersIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetProtocolConfigParametersIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetProtocolConfigParametersIndMsgT_v02, suplSecurity) - QMI_IDL_OFFSET8(qmiLocGetProtocolConfigParametersIndMsgT_v02, suplSecurity_valid)),
+  0x10,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetProtocolConfigParametersIndMsgT_v02, suplSecurity),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetProtocolConfigParametersIndMsgT_v02, vxVersion) - QMI_IDL_OFFSET8(qmiLocGetProtocolConfigParametersIndMsgT_v02, vxVersion_valid)),
+  0x11,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetProtocolConfigParametersIndMsgT_v02, vxVersion),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetProtocolConfigParametersIndMsgT_v02, suplVersion) - QMI_IDL_OFFSET8(qmiLocGetProtocolConfigParametersIndMsgT_v02, suplVersion_valid)),
+  0x12,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetProtocolConfigParametersIndMsgT_v02, suplVersion),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetProtocolConfigParametersIndMsgT_v02, lppConfig) - QMI_IDL_OFFSET8(qmiLocGetProtocolConfigParametersIndMsgT_v02, lppConfig_valid)),
+  0x13,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetProtocolConfigParametersIndMsgT_v02, lppConfig),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetProtocolConfigParametersIndMsgT_v02, assistedGlonassProtocolMask) - QMI_IDL_OFFSET8(qmiLocGetProtocolConfigParametersIndMsgT_v02, assistedGlonassProtocolMask_valid)),
+  0x14,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetProtocolConfigParametersIndMsgT_v02, assistedGlonassProtocolMask),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetProtocolConfigParametersIndMsgT_v02, suplHashAlgo) - QMI_IDL_OFFSET8(qmiLocGetProtocolConfigParametersIndMsgT_v02, suplHashAlgo_valid)),
+  0x15,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetProtocolConfigParametersIndMsgT_v02, suplHashAlgo),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetProtocolConfigParametersIndMsgT_v02, suplTlsVersion) - QMI_IDL_OFFSET8(qmiLocGetProtocolConfigParametersIndMsgT_v02, suplTlsVersion_valid)),
+  0x16,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetProtocolConfigParametersIndMsgT_v02, suplTlsVersion),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetProtocolConfigParametersIndMsgT_v02, emergencyProtocol) - QMI_IDL_OFFSET8(qmiLocGetProtocolConfigParametersIndMsgT_v02, emergencyProtocol_valid)),
+  0x17,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetProtocolConfigParametersIndMsgT_v02, emergencyProtocol),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetProtocolConfigParametersIndMsgT_v02, wifiScanInjectTimeout) - QMI_IDL_OFFSET8(qmiLocGetProtocolConfigParametersIndMsgT_v02, wifiScanInjectTimeout_valid)),
+  0x18,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetProtocolConfigParametersIndMsgT_v02, wifiScanInjectTimeout),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetProtocolConfigParametersIndMsgT_v02, lppeUpConfig) - QMI_IDL_OFFSET8(qmiLocGetProtocolConfigParametersIndMsgT_v02, lppeUpConfig_valid)),
+  0x19,
+   QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetProtocolConfigParametersIndMsgT_v02, lppeUpConfig),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetProtocolConfigParametersIndMsgT_v02, lppeCpConfig) - QMI_IDL_OFFSET8(qmiLocGetProtocolConfigParametersIndMsgT_v02, lppeCpConfig_valid)),
+  0x1A,
+   QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetProtocolConfigParametersIndMsgT_v02, lppeCpConfig)
+};
+
+static const uint8_t qmiLocSetSensorControlConfigReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetSensorControlConfigReqMsgT_v02, sensorsUsage) - QMI_IDL_OFFSET8(qmiLocSetSensorControlConfigReqMsgT_v02, sensorsUsage_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetSensorControlConfigReqMsgT_v02, sensorsUsage),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetSensorControlConfigReqMsgT_v02, sensorProvider) - QMI_IDL_OFFSET8(qmiLocSetSensorControlConfigReqMsgT_v02, sensorProvider_valid)),
+  0x11,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetSensorControlConfigReqMsgT_v02, sensorProvider)
+};
+
+static const uint8_t qmiLocSetSensorControlConfigIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetSensorControlConfigIndMsgT_v02, status)
+};
+
+/*
+ * qmiLocGetSensorControlConfigReqMsgT is empty
+ * static const uint8_t qmiLocGetSensorControlConfigReqMsgT_data_v02[] = {
+ * };
+ */
+
+static const uint8_t qmiLocGetSensorControlConfigIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetSensorControlConfigIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetSensorControlConfigIndMsgT_v02, sensorsUsage) - QMI_IDL_OFFSET8(qmiLocGetSensorControlConfigIndMsgT_v02, sensorsUsage_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetSensorControlConfigIndMsgT_v02, sensorsUsage),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetSensorControlConfigIndMsgT_v02, sensorProvider) - QMI_IDL_OFFSET8(qmiLocGetSensorControlConfigIndMsgT_v02, sensorProvider_valid)),
+  0x11,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetSensorControlConfigIndMsgT_v02, sensorProvider)
+};
+
+static const uint8_t qmiLocSetSensorPropertiesReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesReqMsgT_v02, gyroBiasVarianceRandomWalk) - QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesReqMsgT_v02, gyroBiasVarianceRandomWalk_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesReqMsgT_v02, gyroBiasVarianceRandomWalk),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesReqMsgT_v02, velocityRandomWalkSpectralDensity) - QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesReqMsgT_v02, velocityRandomWalkSpectralDensity_valid)),
+  0x11,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesReqMsgT_v02, velocityRandomWalkSpectralDensity),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesReqMsgT_v02, accelerationRandomWalkSpectralDensity) - QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesReqMsgT_v02, accelerationRandomWalkSpectralDensity_valid)),
+  0x12,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesReqMsgT_v02, accelerationRandomWalkSpectralDensity),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesReqMsgT_v02, angleRandomWalkSpectralDensity) - QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesReqMsgT_v02, angleRandomWalkSpectralDensity_valid)),
+  0x13,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesReqMsgT_v02, angleRandomWalkSpectralDensity),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesReqMsgT_v02, rateRandomWalkSpectralDensity) - QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesReqMsgT_v02, rateRandomWalkSpectralDensity_valid)),
+  0x14,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesReqMsgT_v02, rateRandomWalkSpectralDensity),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesReqMsgT_v02, vehicleDataUse) - QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesReqMsgT_v02, vehicleDataUse_valid)),
+  0x15,
+   QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesReqMsgT_v02, vehicleDataUse),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesReqMsgT_v02, vehicleVelocityRandomWalkSpectralDensity) - QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesReqMsgT_v02, vehicleVelocityRandomWalkSpectralDensity_valid)),
+  0x16,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesReqMsgT_v02, vehicleVelocityRandomWalkSpectralDensity),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesReqMsgT_v02, vehicleAccelRandomWalkSpectralDensity) - QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesReqMsgT_v02, vehicleAccelRandomWalkSpectralDensity_valid)),
+  0x17,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesReqMsgT_v02, vehicleAccelRandomWalkSpectralDensity),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesReqMsgT_v02, vehicleAngleRandomWalkSpectralDensity) - QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesReqMsgT_v02, vehicleAngleRandomWalkSpectralDensity_valid)),
+  0x18,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesReqMsgT_v02, vehicleAngleRandomWalkSpectralDensity),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesReqMsgT_v02, vehicleAngularRateRandomWalkSpectralDensity) - QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesReqMsgT_v02, vehicleAngularRateRandomWalkSpectralDensity_valid)),
+  0x19,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesReqMsgT_v02, vehicleAngularRateRandomWalkSpectralDensity),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesReqMsgT_v02, vehicleOdometryScaleFactorRandomWalkSpectralDensity) - QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesReqMsgT_v02, vehicleOdometryScaleFactorRandomWalkSpectralDensity_valid)),
+  0x1A,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesReqMsgT_v02, vehicleOdometryScaleFactorRandomWalkSpectralDensity),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesReqMsgT_v02, vehicleOdometryVariance) - QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesReqMsgT_v02, vehicleOdometryVariance_valid)),
+  0x1B,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesReqMsgT_v02, vehicleOdometryVariance)
+};
+
+static const uint8_t qmiLocSetSensorPropertiesIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesIndMsgT_v02, failedSensorPropertiesMask) - QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesIndMsgT_v02, failedSensorPropertiesMask_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetSensorPropertiesIndMsgT_v02, failedSensorPropertiesMask)
+};
+
+static const uint8_t qmiLocGetSensorPropertiesReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesReqMsgT_v02, getSensorPropertiesMask)
+};
+
+static const uint8_t qmiLocGetSensorPropertiesIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, gyroBiasVarianceRandomWalk) - QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, gyroBiasVarianceRandomWalk_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, gyroBiasVarianceRandomWalk),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, velocityRandomWalkSpectralDensity) - QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, velocityRandomWalkSpectralDensity_valid)),
+  0x11,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, velocityRandomWalkSpectralDensity),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, accelerationRandomWalkSpectralDensity) - QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, accelerationRandomWalkSpectralDensity_valid)),
+  0x12,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, accelerationRandomWalkSpectralDensity),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, angleRandomWalkSpectralDensity) - QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, angleRandomWalkSpectralDensity_valid)),
+  0x13,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, angleRandomWalkSpectralDensity),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, rateRandomWalkSpectralDensity) - QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, rateRandomWalkSpectralDensity_valid)),
+  0x14,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, rateRandomWalkSpectralDensity),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, vehicleDataUse) - QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, vehicleDataUse_valid)),
+  0x15,
+   QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, vehicleDataUse),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, vehicleVelocityRandomWalkSpectralDensity) - QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, vehicleVelocityRandomWalkSpectralDensity_valid)),
+  0x16,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, vehicleVelocityRandomWalkSpectralDensity),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, vehicleAccelRandomWalkSpectralDensity) - QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, vehicleAccelRandomWalkSpectralDensity_valid)),
+  0x17,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, vehicleAccelRandomWalkSpectralDensity),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, vehicleAngleRandomWalkSpectralDensity) - QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, vehicleAngleRandomWalkSpectralDensity_valid)),
+  0x18,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, vehicleAngleRandomWalkSpectralDensity),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, vehicleAngularRateRandomWalkSpectralDensity) - QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, vehicleAngularRateRandomWalkSpectralDensity_valid)),
+  0x19,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, vehicleAngularRateRandomWalkSpectralDensity),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, vehicleOdometryScaleFactorRandomWalkSpectralDensity) - QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, vehicleOdometryScaleFactorRandomWalkSpectralDensity_valid)),
+  0x1A,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, vehicleOdometryScaleFactorRandomWalkSpectralDensity),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, vehicleOdometryVariance) - QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, vehicleOdometryVariance_valid)),
+  0x1B,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetSensorPropertiesIndMsgT_v02, vehicleOdometryVariance)
+};
+
+static const uint8_t qmiLocSetSensorPerformanceControlConfigReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetSensorPerformanceControlConfigReqMsgT_v02, performanceControlMode) - QMI_IDL_OFFSET8(qmiLocSetSensorPerformanceControlConfigReqMsgT_v02, performanceControlMode_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetSensorPerformanceControlConfigReqMsgT_v02, performanceControlMode),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetSensorPerformanceControlConfigReqMsgT_v02, accelSamplingSpec) - QMI_IDL_OFFSET8(qmiLocSetSensorPerformanceControlConfigReqMsgT_v02, accelSamplingSpec_valid)),
+  0x11,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocSetSensorPerformanceControlConfigReqMsgT_v02, accelSamplingSpec),
+  QMI_IDL_TYPE88(0, 21),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetSensorPerformanceControlConfigReqMsgT_v02, gyroSamplingSpec) - QMI_IDL_OFFSET8(qmiLocSetSensorPerformanceControlConfigReqMsgT_v02, gyroSamplingSpec_valid)),
+  0x12,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocSetSensorPerformanceControlConfigReqMsgT_v02, gyroSamplingSpec),
+  QMI_IDL_TYPE88(0, 21),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetSensorPerformanceControlConfigReqMsgT_v02, algorithmConfig) - QMI_IDL_OFFSET8(qmiLocSetSensorPerformanceControlConfigReqMsgT_v02, algorithmConfig_valid)),
+  0x13,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetSensorPerformanceControlConfigReqMsgT_v02, algorithmConfig),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetSensorPerformanceControlConfigReqMsgT_v02, accelSamplingSpecHigh) - QMI_IDL_OFFSET8(qmiLocSetSensorPerformanceControlConfigReqMsgT_v02, accelSamplingSpecHigh_valid)),
+  0x14,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocSetSensorPerformanceControlConfigReqMsgT_v02, accelSamplingSpecHigh),
+  QMI_IDL_TYPE88(0, 21),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetSensorPerformanceControlConfigReqMsgT_v02, gyroSamplingSpecHigh) - QMI_IDL_OFFSET8(qmiLocSetSensorPerformanceControlConfigReqMsgT_v02, gyroSamplingSpecHigh_valid)),
+  0x15,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocSetSensorPerformanceControlConfigReqMsgT_v02, gyroSamplingSpecHigh),
+  QMI_IDL_TYPE88(0, 21)
+};
+
+static const uint8_t qmiLocSetSensorPerformanceControlConfigIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetSensorPerformanceControlConfigIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetSensorPerformanceControlConfigIndMsgT_v02, failedConfiguration) - QMI_IDL_OFFSET8(qmiLocSetSensorPerformanceControlConfigIndMsgT_v02, failedConfiguration_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetSensorPerformanceControlConfigIndMsgT_v02, failedConfiguration)
+};
+
+/*
+ * qmiLocGetSensorPerformanceControlConfigReqMsgT is empty
+ * static const uint8_t qmiLocGetSensorPerformanceControlConfigReqMsgT_data_v02[] = {
+ * };
+ */
+
+static const uint8_t qmiLocGetSensorPerformanceControlConfigIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetSensorPerformanceControlConfigIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetSensorPerformanceControlConfigIndMsgT_v02, performanceControlMode) - QMI_IDL_OFFSET8(qmiLocGetSensorPerformanceControlConfigIndMsgT_v02, performanceControlMode_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetSensorPerformanceControlConfigIndMsgT_v02, performanceControlMode),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetSensorPerformanceControlConfigIndMsgT_v02, accelSamplingSpec) - QMI_IDL_OFFSET8(qmiLocGetSensorPerformanceControlConfigIndMsgT_v02, accelSamplingSpec_valid)),
+  0x11,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocGetSensorPerformanceControlConfigIndMsgT_v02, accelSamplingSpec),
+  QMI_IDL_TYPE88(0, 21),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetSensorPerformanceControlConfigIndMsgT_v02, gyroSamplingSpec) - QMI_IDL_OFFSET8(qmiLocGetSensorPerformanceControlConfigIndMsgT_v02, gyroSamplingSpec_valid)),
+  0x12,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocGetSensorPerformanceControlConfigIndMsgT_v02, gyroSamplingSpec),
+  QMI_IDL_TYPE88(0, 21),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetSensorPerformanceControlConfigIndMsgT_v02, algorithmConfig) - QMI_IDL_OFFSET8(qmiLocGetSensorPerformanceControlConfigIndMsgT_v02, algorithmConfig_valid)),
+  0x13,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetSensorPerformanceControlConfigIndMsgT_v02, algorithmConfig),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetSensorPerformanceControlConfigIndMsgT_v02, accelSamplingSpecHigh) - QMI_IDL_OFFSET8(qmiLocGetSensorPerformanceControlConfigIndMsgT_v02, accelSamplingSpecHigh_valid)),
+  0x14,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocGetSensorPerformanceControlConfigIndMsgT_v02, accelSamplingSpecHigh),
+  QMI_IDL_TYPE88(0, 21),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetSensorPerformanceControlConfigIndMsgT_v02, gyroSamplingSpecHigh) - QMI_IDL_OFFSET8(qmiLocGetSensorPerformanceControlConfigIndMsgT_v02, gyroSamplingSpecHigh_valid)),
+  0x15,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocGetSensorPerformanceControlConfigIndMsgT_v02, gyroSamplingSpecHigh),
+  QMI_IDL_TYPE88(0, 21)
+};
+
+static const uint8_t qmiLocInjectSuplCertificateReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectSuplCertificateReqMsgT_v02, suplCertId),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x02,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN | QMI_IDL_FLAGS_SZ_IS_16 |   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectSuplCertificateReqMsgT_v02, suplCertData),
+  ((QMI_LOC_MAX_SUPL_CERT_LENGTH_V02) & 0xFF), ((QMI_LOC_MAX_SUPL_CERT_LENGTH_V02) >> 8),
+  QMI_IDL_OFFSET8(qmiLocInjectSuplCertificateReqMsgT_v02, suplCertData) - QMI_IDL_OFFSET8(qmiLocInjectSuplCertificateReqMsgT_v02, suplCertData_len)
+};
+
+static const uint8_t qmiLocInjectSuplCertificateIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectSuplCertificateIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocDeleteSuplCertificateReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocDeleteSuplCertificateReqMsgT_v02, suplCertId) - QMI_IDL_OFFSET8(qmiLocDeleteSuplCertificateReqMsgT_v02, suplCertId_valid)),
+  0x10,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDeleteSuplCertificateReqMsgT_v02, suplCertId)
+};
+
+static const uint8_t qmiLocDeleteSuplCertificateIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDeleteSuplCertificateIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocSetPositionEngineConfigParametersReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetPositionEngineConfigParametersReqMsgT_v02, injectedPositionControl) - QMI_IDL_OFFSET8(qmiLocSetPositionEngineConfigParametersReqMsgT_v02, injectedPositionControl_valid)),
+  0x10,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetPositionEngineConfigParametersReqMsgT_v02, injectedPositionControl),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetPositionEngineConfigParametersReqMsgT_v02, filterSvUsage) - QMI_IDL_OFFSET8(qmiLocSetPositionEngineConfigParametersReqMsgT_v02, filterSvUsage_valid)),
+  0x11,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetPositionEngineConfigParametersReqMsgT_v02, filterSvUsage),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetPositionEngineConfigParametersReqMsgT_v02, storeAssistData) - QMI_IDL_OFFSET8(qmiLocSetPositionEngineConfigParametersReqMsgT_v02, storeAssistData_valid)),
+  0x12,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetPositionEngineConfigParametersReqMsgT_v02, storeAssistData),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetPositionEngineConfigParametersReqMsgT_v02, enableFasterTTFF) - QMI_IDL_OFFSET8(qmiLocSetPositionEngineConfigParametersReqMsgT_v02, enableFasterTTFF_valid)),
+  0x13,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetPositionEngineConfigParametersReqMsgT_v02, enableFasterTTFF)
+};
+
+static const uint8_t qmiLocSetPositionEngineConfigParametersIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetPositionEngineConfigParametersIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetPositionEngineConfigParametersIndMsgT_v02, failedPositionEngineConfigParamMask) - QMI_IDL_OFFSET8(qmiLocSetPositionEngineConfigParametersIndMsgT_v02, failedPositionEngineConfigParamMask_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetPositionEngineConfigParametersIndMsgT_v02, failedPositionEngineConfigParamMask)
+};
+
+static const uint8_t qmiLocGetPositionEngineConfigParametersReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetPositionEngineConfigParametersReqMsgT_v02, getPositionEngineConfigParamMask)
+};
+
+static const uint8_t qmiLocGetPositionEngineConfigParametersIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetPositionEngineConfigParametersIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetPositionEngineConfigParametersIndMsgT_v02, injectedPositionControl) - QMI_IDL_OFFSET8(qmiLocGetPositionEngineConfigParametersIndMsgT_v02, injectedPositionControl_valid)),
+  0x10,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetPositionEngineConfigParametersIndMsgT_v02, injectedPositionControl),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetPositionEngineConfigParametersIndMsgT_v02, filterSvUsage) - QMI_IDL_OFFSET8(qmiLocGetPositionEngineConfigParametersIndMsgT_v02, filterSvUsage_valid)),
+  0x11,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetPositionEngineConfigParametersIndMsgT_v02, filterSvUsage),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetPositionEngineConfigParametersIndMsgT_v02, storeAssistData) - QMI_IDL_OFFSET8(qmiLocGetPositionEngineConfigParametersIndMsgT_v02, storeAssistData_valid)),
+  0x12,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetPositionEngineConfigParametersIndMsgT_v02, storeAssistData),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetPositionEngineConfigParametersIndMsgT_v02, enableFasterTTFF) - QMI_IDL_OFFSET8(qmiLocGetPositionEngineConfigParametersIndMsgT_v02, enableFasterTTFF_valid)),
+  0x13,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetPositionEngineConfigParametersIndMsgT_v02, enableFasterTTFF)
+};
+
+static const uint8_t qmiLocAddCircularGeofenceReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocAddCircularGeofenceReqMsgT_v02, transactionId),
+
+  0x02,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocAddCircularGeofenceReqMsgT_v02, circularGeofenceArgs),
+  QMI_IDL_TYPE88(0, 39),
+
+  0x03,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocAddCircularGeofenceReqMsgT_v02, breachMask),
+
+  0x04,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocAddCircularGeofenceReqMsgT_v02, includePosition),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocAddCircularGeofenceReqMsgT_v02, responsiveness) - QMI_IDL_OFFSET8(qmiLocAddCircularGeofenceReqMsgT_v02, responsiveness_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocAddCircularGeofenceReqMsgT_v02, responsiveness),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocAddCircularGeofenceReqMsgT_v02, confidence) - QMI_IDL_OFFSET8(qmiLocAddCircularGeofenceReqMsgT_v02, confidence_valid)),
+  0x11,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocAddCircularGeofenceReqMsgT_v02, confidence),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocAddCircularGeofenceReqMsgT_v02, customResponsivenessValue) - QMI_IDL_OFFSET8(qmiLocAddCircularGeofenceReqMsgT_v02, customResponsivenessValue_valid)),
+  0x12,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocAddCircularGeofenceReqMsgT_v02, customResponsivenessValue),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocAddCircularGeofenceReqMsgT_v02, dwellTime) - QMI_IDL_OFFSET8(qmiLocAddCircularGeofenceReqMsgT_v02, dwellTime_valid)),
+  0x13,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocAddCircularGeofenceReqMsgT_v02, dwellTime),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocAddCircularGeofenceReqMsgT_v02, dwellTypeMask) - QMI_IDL_OFFSET8(qmiLocAddCircularGeofenceReqMsgT_v02, dwellTypeMask_valid)),
+  0x14,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocAddCircularGeofenceReqMsgT_v02, dwellTypeMask)
+};
+
+static const uint8_t qmiLocAddCircularGeofenceIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocAddCircularGeofenceIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocAddCircularGeofenceIndMsgT_v02, transactionId) - QMI_IDL_OFFSET8(qmiLocAddCircularGeofenceIndMsgT_v02, transactionId_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocAddCircularGeofenceIndMsgT_v02, transactionId),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocAddCircularGeofenceIndMsgT_v02, geofenceId) - QMI_IDL_OFFSET8(qmiLocAddCircularGeofenceIndMsgT_v02, geofenceId_valid)),
+  0x11,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocAddCircularGeofenceIndMsgT_v02, geofenceId)
+};
+
+static const uint8_t qmiLocDeleteGeofenceReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDeleteGeofenceReqMsgT_v02, geofenceId),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDeleteGeofenceReqMsgT_v02, transactionId)
+};
+
+static const uint8_t qmiLocDeleteGeofenceIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDeleteGeofenceIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocDeleteGeofenceIndMsgT_v02, geofenceId) - QMI_IDL_OFFSET8(qmiLocDeleteGeofenceIndMsgT_v02, geofenceId_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDeleteGeofenceIndMsgT_v02, geofenceId),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocDeleteGeofenceIndMsgT_v02, transactionId) - QMI_IDL_OFFSET8(qmiLocDeleteGeofenceIndMsgT_v02, transactionId_valid)),
+  0x11,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDeleteGeofenceIndMsgT_v02, transactionId)
+};
+
+static const uint8_t qmiLocQueryGeofenceReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocQueryGeofenceReqMsgT_v02, geofenceId),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocQueryGeofenceReqMsgT_v02, transactionId)
+};
+
+static const uint8_t qmiLocQueryGeofenceIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocQueryGeofenceIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocQueryGeofenceIndMsgT_v02, geofenceId) - QMI_IDL_OFFSET8(qmiLocQueryGeofenceIndMsgT_v02, geofenceId_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocQueryGeofenceIndMsgT_v02, geofenceId),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocQueryGeofenceIndMsgT_v02, transactionId) - QMI_IDL_OFFSET8(qmiLocQueryGeofenceIndMsgT_v02, transactionId_valid)),
+  0x11,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocQueryGeofenceIndMsgT_v02, transactionId),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocQueryGeofenceIndMsgT_v02, geofenceOrigin) - QMI_IDL_OFFSET8(qmiLocQueryGeofenceIndMsgT_v02, geofenceOrigin_valid)),
+  0x12,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocQueryGeofenceIndMsgT_v02, geofenceOrigin),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocQueryGeofenceIndMsgT_v02, posWrtGeofence) - QMI_IDL_OFFSET8(qmiLocQueryGeofenceIndMsgT_v02, posWrtGeofence_valid)),
+  0x13,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocQueryGeofenceIndMsgT_v02, posWrtGeofence),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocQueryGeofenceIndMsgT_v02, circularGeofenceArgs) - QMI_IDL_OFFSET8(qmiLocQueryGeofenceIndMsgT_v02, circularGeofenceArgs_valid)),
+  0x14,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocQueryGeofenceIndMsgT_v02, circularGeofenceArgs),
+  QMI_IDL_TYPE88(0, 39),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocQueryGeofenceIndMsgT_v02, geofenceState) - QMI_IDL_OFFSET8(qmiLocQueryGeofenceIndMsgT_v02, geofenceState_valid)),
+  0x15,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocQueryGeofenceIndMsgT_v02, geofenceState)
+};
+
+static const uint8_t qmiLocSetGeofenceEngineConfigReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineConfigReqMsgT_v02, transactionId),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineConfigReqMsgT_v02, gnssUnavailableIndicationTimeout) - QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineConfigReqMsgT_v02, gnssUnavailableIndicationTimeout_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineConfigReqMsgT_v02, gnssUnavailableIndicationTimeout),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineConfigReqMsgT_v02, maxGeofences) - QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineConfigReqMsgT_v02, maxGeofences_valid)),
+  0x11,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineConfigReqMsgT_v02, maxGeofences),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineConfigReqMsgT_v02, enableMotionDetectionSources) - QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineConfigReqMsgT_v02, enableMotionDetectionSources_valid)),
+  0x12,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineConfigReqMsgT_v02, enableMotionDetectionSources),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineConfigReqMsgT_v02, enableCpiUsage) - QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineConfigReqMsgT_v02, enableCpiUsage_valid)),
+  0x13,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineConfigReqMsgT_v02, enableCpiUsage),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineConfigReqMsgT_v02, gnssPositionSessionTimeout) - QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineConfigReqMsgT_v02, gnssPositionSessionTimeout_valid)),
+  0x14,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineConfigReqMsgT_v02, gnssPositionSessionTimeout),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineConfigReqMsgT_v02, gnssPositionMaxPuncAcceptable) - QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineConfigReqMsgT_v02, gnssPositionMaxPuncAcceptable_valid)),
+  0x15,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineConfigReqMsgT_v02, gnssPositionMaxPuncAcceptable),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineConfigReqMsgT_v02, mediumResponsivenessValue) - QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineConfigReqMsgT_v02, mediumResponsivenessValue_valid)),
+  0x16,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineConfigReqMsgT_v02, mediumResponsivenessValue),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineConfigReqMsgT_v02, chalGnssEnvMinCpiWaitInterval) - QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineConfigReqMsgT_v02, chalGnssEnvMinCpiWaitInterval_valid)),
+  0x17,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineConfigReqMsgT_v02, chalGnssEnvMinCpiWaitInterval),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineConfigReqMsgT_v02, motionStateInfo) - QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineConfigReqMsgT_v02, motionStateInfo_valid)),
+  0x18,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineConfigReqMsgT_v02, motionStateInfo),
+  QMI_LOC_GEOFENCE_MAX_MOTION_STATES_V02,
+  QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineConfigReqMsgT_v02, motionStateInfo) - QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineConfigReqMsgT_v02, motionStateInfo_len),
+  QMI_IDL_TYPE88(0, 40)
+};
+
+static const uint8_t qmiLocSetGeofenceEngineConfigIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineConfigIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineConfigIndMsgT_v02, transactionId) - QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineConfigIndMsgT_v02, transactionId_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineConfigIndMsgT_v02, transactionId)
+};
+
+static const uint8_t qmiLocGetGeofenceEngineConfigReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetGeofenceEngineConfigReqMsgT_v02, transactionId)
+};
+
+static const uint8_t qmiLocGetGeofenceEngineConfigIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetGeofenceEngineConfigIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetGeofenceEngineConfigIndMsgT_v02, transactionId) - QMI_IDL_OFFSET8(qmiLocGetGeofenceEngineConfigIndMsgT_v02, transactionId_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetGeofenceEngineConfigIndMsgT_v02, transactionId),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetGeofenceEngineConfigIndMsgT_v02, gnssUnavailableIndicationTimeout) - QMI_IDL_OFFSET8(qmiLocGetGeofenceEngineConfigIndMsgT_v02, gnssUnavailableIndicationTimeout_valid)),
+  0x11,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetGeofenceEngineConfigIndMsgT_v02, gnssUnavailableIndicationTimeout),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetGeofenceEngineConfigIndMsgT_v02, maxGeofences) - QMI_IDL_OFFSET8(qmiLocGetGeofenceEngineConfigIndMsgT_v02, maxGeofences_valid)),
+  0x12,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetGeofenceEngineConfigIndMsgT_v02, maxGeofences),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetGeofenceEngineConfigIndMsgT_v02, enabledMotionDetectionSources) - QMI_IDL_OFFSET8(qmiLocGetGeofenceEngineConfigIndMsgT_v02, enabledMotionDetectionSources_valid)),
+  0x13,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetGeofenceEngineConfigIndMsgT_v02, enabledMotionDetectionSources),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetGeofenceEngineConfigIndMsgT_v02, enabledCpiUsage) - QMI_IDL_OFFSET8(qmiLocGetGeofenceEngineConfigIndMsgT_v02, enabledCpiUsage_valid)),
+  0x14,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetGeofenceEngineConfigIndMsgT_v02, enabledCpiUsage)
+};
+
+static const uint8_t qmiLocEditGeofenceReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEditGeofenceReqMsgT_v02, geofenceId),
+
+  0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEditGeofenceReqMsgT_v02, transactionId),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEditGeofenceReqMsgT_v02, geofenceState) - QMI_IDL_OFFSET8(qmiLocEditGeofenceReqMsgT_v02, geofenceState_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEditGeofenceReqMsgT_v02, geofenceState),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEditGeofenceReqMsgT_v02, breachMask) - QMI_IDL_OFFSET8(qmiLocEditGeofenceReqMsgT_v02, breachMask_valid)),
+  0x11,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEditGeofenceReqMsgT_v02, breachMask),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEditGeofenceReqMsgT_v02, responsiveness) - QMI_IDL_OFFSET8(qmiLocEditGeofenceReqMsgT_v02, responsiveness_valid)),
+  0x12,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEditGeofenceReqMsgT_v02, responsiveness)
+};
+
+static const uint8_t qmiLocEditGeofenceIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEditGeofenceIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEditGeofenceIndMsgT_v02, geofenceId) - QMI_IDL_OFFSET8(qmiLocEditGeofenceIndMsgT_v02, geofenceId_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEditGeofenceIndMsgT_v02, geofenceId),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEditGeofenceIndMsgT_v02, transactionId) - QMI_IDL_OFFSET8(qmiLocEditGeofenceIndMsgT_v02, transactionId_valid)),
+  0x11,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEditGeofenceIndMsgT_v02, transactionId),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEditGeofenceIndMsgT_v02, failedParams) - QMI_IDL_OFFSET8(qmiLocEditGeofenceIndMsgT_v02, failedParams_valid)),
+  0x12,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEditGeofenceIndMsgT_v02, failedParams)
+};
+
+static const uint8_t qmiLocEventGetTimeZoneReqIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGetTimeZoneReqIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocInjectTimeZoneInfoReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectTimeZoneInfoReqMsgT_v02, timeUtc),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x02,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocInjectTimeZoneInfoReqMsgT_v02, timeZone),
+  QMI_IDL_TYPE88(0, 41)
+};
+
+static const uint8_t qmiLocInjectTimeZoneInfoIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectTimeZoneInfoIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocGetBestAvailablePositionReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionReqMsgT_v02, transactionId)
+};
+
+static const uint8_t qmiLocGetBestAvailablePositionIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, transactionId) - QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, transactionId_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, transactionId),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, latitude) - QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, latitude_valid)),
+  0x11,
+   QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, latitude),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, longitude) - QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, longitude_valid)),
+  0x12,
+   QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, longitude),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, horUncCircular) - QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, horUncCircular_valid)),
+  0x13,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, horUncCircular),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, altitudeWrtEllipsoid) - QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, altitudeWrtEllipsoid_valid)),
+  0x14,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, altitudeWrtEllipsoid),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, vertUnc) - QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, vertUnc_valid)),
+  0x15,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, vertUnc),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, timestampUtc) - QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, timestampUtc_valid)),
+  0x16,
+   QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, timestampUtc),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, timeUnc) - QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, timeUnc_valid)),
+  0x17,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, timeUnc),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, horUncEllipseSemiMinor) - QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, horUncEllipseSemiMinor_valid)),
+  0x18,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, horUncEllipseSemiMinor),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, horUncEllipseSemiMajor) - QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, horUncEllipseSemiMajor_valid)),
+  0x19,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, horUncEllipseSemiMajor),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, horUncEllipseOrientAzimuth) - QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, horUncEllipseOrientAzimuth_valid)),
+  0x1A,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, horUncEllipseOrientAzimuth),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, horCircularConfidence) - QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, horCircularConfidence_valid)),
+  0x1B,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, horCircularConfidence),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, horEllipticalConfidence) - QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, horEllipticalConfidence_valid)),
+  0x1C,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, horEllipticalConfidence),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, horReliability) - QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, horReliability_valid)),
+  0x1D,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, horReliability),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, horSpeed) - QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, horSpeed_valid)),
+  0x1E,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, horSpeed),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, horSpeedUnc) - QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, horSpeedUnc_valid)),
+  0x1F,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, horSpeedUnc),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, altitudeWrtMeanSeaLevel) - QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, altitudeWrtMeanSeaLevel_valid)),
+  0x20,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, altitudeWrtMeanSeaLevel),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, vertConfidence) - QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, vertConfidence_valid)),
+  0x21,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, vertConfidence),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, vertReliability) - QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, vertReliability_valid)),
+  0x22,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, vertReliability),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, vertSpeed) - QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, vertSpeed_valid)),
+  0x23,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, vertSpeed),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, vertSpeedUnc) - QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, vertSpeedUnc_valid)),
+  0x24,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, vertSpeedUnc),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, heading) - QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, heading_valid)),
+  0x25,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, heading),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, headingUnc) - QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, headingUnc_valid)),
+  0x26,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, headingUnc),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, magneticDeviation) - QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, magneticDeviation_valid)),
+  0x27,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, magneticDeviation),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, technologyMask) - QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, technologyMask_valid)),
+  0x28,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, technologyMask),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, DOP) - QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, DOP_valid)),
+  0x29,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocGetBestAvailablePositionIndMsgT_v02, DOP),
+  QMI_IDL_TYPE88(0, 2),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocGetBestAvailablePositionIndMsgT_v02, gpsTime) - QMI_IDL_OFFSET16RELATIVE(qmiLocGetBestAvailablePositionIndMsgT_v02, gpsTime_valid)),
+  0x2A,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocGetBestAvailablePositionIndMsgT_v02, gpsTime),
+  QMI_IDL_TYPE88(0, 1),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocGetBestAvailablePositionIndMsgT_v02, timeSrc) - QMI_IDL_OFFSET16RELATIVE(qmiLocGetBestAvailablePositionIndMsgT_v02, timeSrc_valid)),
+  0x2B,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocGetBestAvailablePositionIndMsgT_v02, timeSrc),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocGetBestAvailablePositionIndMsgT_v02, sensorDataUsage) - QMI_IDL_OFFSET16RELATIVE(qmiLocGetBestAvailablePositionIndMsgT_v02, sensorDataUsage_valid)),
+  0x2C,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocGetBestAvailablePositionIndMsgT_v02, sensorDataUsage),
+  QMI_IDL_TYPE88(0, 3),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocGetBestAvailablePositionIndMsgT_v02, gnssSvUsedList) - QMI_IDL_OFFSET16RELATIVE(qmiLocGetBestAvailablePositionIndMsgT_v02, gnssSvUsedList_valid)),
+  0x2D,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocGetBestAvailablePositionIndMsgT_v02, gnssSvUsedList),
+  QMI_LOC_MAX_SV_USED_LIST_LENGTH_V02,
+  QMI_IDL_OFFSET16RELATIVE(qmiLocGetBestAvailablePositionIndMsgT_v02, gnssSvUsedList) - QMI_IDL_OFFSET16RELATIVE(qmiLocGetBestAvailablePositionIndMsgT_v02, gnssSvUsedList_len)
+};
+
+static const uint8_t qmiLocInjectMotionDataReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocInjectMotionDataReqMsgT_v02, motion_data),
+  QMI_IDL_TYPE88(0, 42)
+};
+
+static const uint8_t qmiLocInjectMotionDataIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectMotionDataIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocGetNiGeofenceIdListReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetNiGeofenceIdListReqMsgT_v02, transactionId)
+};
+
+static const uint8_t qmiLocGetNiGeofenceIdListIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetNiGeofenceIdListIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetNiGeofenceIdListIndMsgT_v02, transactionId) - QMI_IDL_OFFSET8(qmiLocGetNiGeofenceIdListIndMsgT_v02, transactionId_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetNiGeofenceIdListIndMsgT_v02, transactionId),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetNiGeofenceIdListIndMsgT_v02, niGeofenceIdList) - QMI_IDL_OFFSET8(qmiLocGetNiGeofenceIdListIndMsgT_v02, niGeofenceIdList_valid)),
+  0x11,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetNiGeofenceIdListIndMsgT_v02, niGeofenceIdList),
+  QMI_LOC_MAX_NI_GEOFENCE_ID_LIST_LENGTH_V02,
+  QMI_IDL_OFFSET8(qmiLocGetNiGeofenceIdListIndMsgT_v02, niGeofenceIdList) - QMI_IDL_OFFSET8(qmiLocGetNiGeofenceIdListIndMsgT_v02, niGeofenceIdList_len)
+};
+
+static const uint8_t qmiLocInjectGSMCellInfoReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocInjectGSMCellInfoReqMsgT_v02, gsmCellId),
+  QMI_IDL_TYPE88(0, 43),
+
+  0x02,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectGSMCellInfoReqMsgT_v02, roamingStatus),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectGSMCellInfoReqMsgT_v02, timingAdvance) - QMI_IDL_OFFSET8(qmiLocInjectGSMCellInfoReqMsgT_v02, timingAdvance_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectGSMCellInfoReqMsgT_v02, timingAdvance)
+};
+
+static const uint8_t qmiLocInjectGSMCellInfoIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectGSMCellInfoIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocInjectWCDMACellInfoReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocInjectWCDMACellInfoReqMsgT_v02, wcdmaCellId),
+  QMI_IDL_TYPE88(0, 44),
+
+  0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectWCDMACellInfoReqMsgT_v02, roamingStatus),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectWCDMACellInfoReqMsgT_v02, freq) - QMI_IDL_OFFSET8(qmiLocInjectWCDMACellInfoReqMsgT_v02, freq_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectWCDMACellInfoReqMsgT_v02, freq),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectWCDMACellInfoReqMsgT_v02, psc) - QMI_IDL_OFFSET8(qmiLocInjectWCDMACellInfoReqMsgT_v02, psc_valid)),
+  0x11,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectWCDMACellInfoReqMsgT_v02, psc)
+};
+
+static const uint8_t qmiLocInjectWCDMACellInfoIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectWCDMACellInfoIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocInjectTDSCDMACellInfoReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocInjectTDSCDMACellInfoReqMsgT_v02, tdscdmaCellId),
+  QMI_IDL_TYPE88(0, 45),
+
+  0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectTDSCDMACellInfoReqMsgT_v02, roamingStatus),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectTDSCDMACellInfoReqMsgT_v02, freq) - QMI_IDL_OFFSET8(qmiLocInjectTDSCDMACellInfoReqMsgT_v02, freq_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectTDSCDMACellInfoReqMsgT_v02, freq)
+};
+
+static const uint8_t qmiLocInjectTDSCDMACellInfoIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectTDSCDMACellInfoIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocInjectSubscriberIDReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectSubscriberIDReqMsgT_v02, preferredIMSI) - QMI_IDL_OFFSET8(qmiLocInjectSubscriberIDReqMsgT_v02, preferredIMSI_valid)),
+  0x10,
+   QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectSubscriberIDReqMsgT_v02, preferredIMSI),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectSubscriberIDReqMsgT_v02, preferredMSISDN) - QMI_IDL_OFFSET8(qmiLocInjectSubscriberIDReqMsgT_v02, preferredMSISDN_valid)),
+  0x11,
+   QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectSubscriberIDReqMsgT_v02, preferredMSISDN)
+};
+
+static const uint8_t qmiLocInjectSubscriberIDIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectSubscriberIDIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocInjectNetworkInitiatedMessageReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectNetworkInitiatedMessageReqMsgT_v02, injectedNIMessageType),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x02,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN | QMI_IDL_FLAGS_SZ_IS_16 |   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectNetworkInitiatedMessageReqMsgT_v02, injectedNIMessage),
+  ((QMI_LOC_MAX_INJECTED_NETWORK_INITIATED_MESSAGE_LENGTH_V02) & 0xFF), ((QMI_LOC_MAX_INJECTED_NETWORK_INITIATED_MESSAGE_LENGTH_V02) >> 8),
+  QMI_IDL_OFFSET8(qmiLocInjectNetworkInitiatedMessageReqMsgT_v02, injectedNIMessage) - QMI_IDL_OFFSET8(qmiLocInjectNetworkInitiatedMessageReqMsgT_v02, injectedNIMessage_len)
+};
+
+static const uint8_t qmiLocInjectNetworkInitiatedMessageIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectNetworkInitiatedMessageIndMsgT_v02, status)
+};
+
+/*
+ * qmiLocWWANOutOfServiceNotificationReqMsgT is empty
+ * static const uint8_t qmiLocWWANOutOfServiceNotificationReqMsgT_data_v02[] = {
+ * };
+ */
+
+static const uint8_t qmiLocWWANOutOfServiceNotificationIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocWWANOutOfServiceNotificationIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocPedometerReportReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocPedometerReportReqMsgT_v02, timeSource),
+
+  0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocPedometerReportReqMsgT_v02, timestamp),
+
+  0x03,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocPedometerReportReqMsgT_v02, timeInterval),
+
+  0x04,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocPedometerReportReqMsgT_v02, stepCount),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocPedometerReportReqMsgT_v02, stepConfidence) - QMI_IDL_OFFSET8(qmiLocPedometerReportReqMsgT_v02, stepConfidence_valid)),
+  0x10,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocPedometerReportReqMsgT_v02, stepConfidence),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocPedometerReportReqMsgT_v02, stepCountUncertainty) - QMI_IDL_OFFSET8(qmiLocPedometerReportReqMsgT_v02, stepCountUncertainty_valid)),
+  0x11,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocPedometerReportReqMsgT_v02, stepCountUncertainty),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocPedometerReportReqMsgT_v02, stepRate) - QMI_IDL_OFFSET8(qmiLocPedometerReportReqMsgT_v02, stepRate_valid)),
+  0x12,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocPedometerReportReqMsgT_v02, stepRate)
+};
+
+static const uint8_t qmiLocPedometerReportIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocPedometerReportIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocGetBatchSizeReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetBatchSizeReqMsgT_v02, transactionId),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetBatchSizeReqMsgT_v02, batchSize)
+};
+
+static const uint8_t qmiLocGetBatchSizeIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetBatchSizeIndMsgT_v02, status),
+
+  0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetBatchSizeIndMsgT_v02, transactionId),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x03,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetBatchSizeIndMsgT_v02, batchSize)
+};
+
+static const uint8_t qmiLocStartBatchingReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocStartBatchingReqMsgT_v02, minInterval) - QMI_IDL_OFFSET8(qmiLocStartBatchingReqMsgT_v02, minInterval_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocStartBatchingReqMsgT_v02, minInterval),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocStartBatchingReqMsgT_v02, horizontalAccuracyLevel) - QMI_IDL_OFFSET8(qmiLocStartBatchingReqMsgT_v02, horizontalAccuracyLevel_valid)),
+  0x11,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocStartBatchingReqMsgT_v02, horizontalAccuracyLevel),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocStartBatchingReqMsgT_v02, fixSessionTimeout) - QMI_IDL_OFFSET8(qmiLocStartBatchingReqMsgT_v02, fixSessionTimeout_valid)),
+  0x12,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocStartBatchingReqMsgT_v02, fixSessionTimeout),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocStartBatchingReqMsgT_v02, minDistance) - QMI_IDL_OFFSET8(qmiLocStartBatchingReqMsgT_v02, minDistance_valid)),
+  0x13,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocStartBatchingReqMsgT_v02, minDistance),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocStartBatchingReqMsgT_v02, batchAllPos) - QMI_IDL_OFFSET8(qmiLocStartBatchingReqMsgT_v02, batchAllPos_valid)),
+  0x14,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocStartBatchingReqMsgT_v02, batchAllPos),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocStartBatchingReqMsgT_v02, requestId) - QMI_IDL_OFFSET8(qmiLocStartBatchingReqMsgT_v02, requestId_valid)),
+  0x15,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocStartBatchingReqMsgT_v02, requestId)
+};
+
+static const uint8_t qmiLocStartBatchingIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocStartBatchingIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocStartBatchingIndMsgT_v02, requestId) - QMI_IDL_OFFSET8(qmiLocStartBatchingIndMsgT_v02, requestId_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocStartBatchingIndMsgT_v02, requestId)
+};
+
+static const uint8_t qmiLocEventBatchFullIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventBatchFullIndMsgT_v02, batchCount)
+};
+
+static const uint8_t qmiLocEventLiveBatchedPositionReportIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocEventLiveBatchedPositionReportIndMsgT_v02, liveBatchedReport),
+  QMI_IDL_TYPE88(0, 46)
+};
+
+static const uint8_t qmiLocReadFromBatchReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocReadFromBatchReqMsgT_v02, numberOfEntries),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocReadFromBatchReqMsgT_v02, transactionId)
+};
+
+static const uint8_t qmiLocReadFromBatchIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocReadFromBatchIndMsgT_v02, status),
+
+  0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocReadFromBatchIndMsgT_v02, transactionId),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocReadFromBatchIndMsgT_v02, numberOfEntries) - QMI_IDL_OFFSET8(qmiLocReadFromBatchIndMsgT_v02, numberOfEntries_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocReadFromBatchIndMsgT_v02, numberOfEntries),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocReadFromBatchIndMsgT_v02, batchedReportList) - QMI_IDL_OFFSET8(qmiLocReadFromBatchIndMsgT_v02, batchedReportList_valid)),
+  0x11,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocReadFromBatchIndMsgT_v02, batchedReportList),
+  QMI_LOC_READ_FROM_BATCH_MAX_SIZE_V02,
+  QMI_IDL_OFFSET8(qmiLocReadFromBatchIndMsgT_v02, batchedReportList) - QMI_IDL_OFFSET8(qmiLocReadFromBatchIndMsgT_v02, batchedReportList_len),
+  QMI_IDL_TYPE88(0, 46)
+};
+
+static const uint8_t qmiLocStopBatchingReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocStopBatchingReqMsgT_v02, transactionId),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocStopBatchingReqMsgT_v02, requestId) - QMI_IDL_OFFSET8(qmiLocStopBatchingReqMsgT_v02, requestId_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocStopBatchingReqMsgT_v02, requestId)
+};
+
+static const uint8_t qmiLocStopBatchingIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocStopBatchingIndMsgT_v02, status),
+
+  0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocStopBatchingIndMsgT_v02, transactionId),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocStopBatchingIndMsgT_v02, requestId) - QMI_IDL_OFFSET8(qmiLocStopBatchingIndMsgT_v02, requestId_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocStopBatchingIndMsgT_v02, requestId)
+};
+
+static const uint8_t qmiLocReleaseBatchReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocReleaseBatchReqMsgT_v02, transactionId)
+};
+
+static const uint8_t qmiLocReleaseBatchIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocReleaseBatchIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocReleaseBatchIndMsgT_v02, transactionId)
+};
+
+static const uint8_t qmiLocEventInjectWifiApDataReqIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventInjectWifiApDataReqIndMsgT_v02, e911Mode) - QMI_IDL_OFFSET8(qmiLocEventInjectWifiApDataReqIndMsgT_v02, e911Mode_valid)),
+  0x10,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventInjectWifiApDataReqIndMsgT_v02, e911Mode)
+};
+
+static const uint8_t qmiLocInjectWifiApDataReqMsgT_data_v02[] = {
+  0x01,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocInjectWifiApDataReqMsgT_v02, wifiApInfo),
+  QMI_LOC_WIFI_MAX_REPORTED_APS_PER_MSG_V02,
+  QMI_IDL_OFFSET8(qmiLocInjectWifiApDataReqMsgT_v02, wifiApInfo) - QMI_IDL_OFFSET8(qmiLocInjectWifiApDataReqMsgT_v02, wifiApInfo_len),
+  QMI_IDL_TYPE88(0, 47),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocInjectWifiApDataReqMsgT_v02, errorCause) - QMI_IDL_OFFSET16RELATIVE(qmiLocInjectWifiApDataReqMsgT_v02, errorCause_valid)),
+  0x10,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocInjectWifiApDataReqMsgT_v02, errorCause),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocInjectWifiApDataReqMsgT_v02, requestTimestamp) - QMI_IDL_OFFSET16RELATIVE(qmiLocInjectWifiApDataReqMsgT_v02, requestTimestamp_valid)),
+  0x11,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocInjectWifiApDataReqMsgT_v02, requestTimestamp),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocInjectWifiApDataReqMsgT_v02, receiveTimestamp) - QMI_IDL_OFFSET16RELATIVE(qmiLocInjectWifiApDataReqMsgT_v02, receiveTimestamp_valid)),
+  0x12,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocInjectWifiApDataReqMsgT_v02, receiveTimestamp),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocInjectWifiApDataReqMsgT_v02, onDemandScan) - QMI_IDL_OFFSET16RELATIVE(qmiLocInjectWifiApDataReqMsgT_v02, onDemandScan_valid)),
+  0x13,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocInjectWifiApDataReqMsgT_v02, onDemandScan),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocInjectWifiApDataReqMsgT_v02, wifiApInfoA) - QMI_IDL_OFFSET16RELATIVE(qmiLocInjectWifiApDataReqMsgT_v02, wifiApInfoA_valid)),
+  0x14,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocInjectWifiApDataReqMsgT_v02, wifiApInfoA),
+  QMI_LOC_WIFI_MAX_REPORTED_APS_PER_MSG_V02,
+  QMI_IDL_OFFSET16RELATIVE(qmiLocInjectWifiApDataReqMsgT_v02, wifiApInfoA) - QMI_IDL_OFFSET16RELATIVE(qmiLocInjectWifiApDataReqMsgT_v02, wifiApInfoA_len),
+  QMI_IDL_TYPE88(0, 48)
+};
+
+static const uint8_t qmiLocInjectWifiApDataIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectWifiApDataIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocNotifyWifiAttachmentStatusReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNotifyWifiAttachmentStatusReqMsgT_v02, attachState),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocNotifyWifiAttachmentStatusReqMsgT_v02, accessPointMacAddress) - QMI_IDL_OFFSET8(qmiLocNotifyWifiAttachmentStatusReqMsgT_v02, accessPointMacAddress_valid)),
+  0x10,
+  QMI_IDL_FLAGS_IS_ARRAY |  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNotifyWifiAttachmentStatusReqMsgT_v02, accessPointMacAddress),
+  QMI_LOC_WIFI_MAC_ADDR_LENGTH_V02,
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocNotifyWifiAttachmentStatusReqMsgT_v02, wifiApSsid) - QMI_IDL_OFFSET8(qmiLocNotifyWifiAttachmentStatusReqMsgT_v02, wifiApSsid_valid)),
+  0x11,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_STRING,
+  QMI_IDL_OFFSET8(qmiLocNotifyWifiAttachmentStatusReqMsgT_v02, wifiApSsid),
+  QMI_LOC_MAX_WIFI_AP_SSID_STR_LENGTH_V02
+};
+
+static const uint8_t qmiLocNotifyWifiAttachmentStatusIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNotifyWifiAttachmentStatusIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocNotifyWifiEnabledStatusReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNotifyWifiEnabledStatusReqMsgT_v02, enabledStatus)
+};
+
+static const uint8_t qmiLocNotifyWifiEnabledStatusIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocNotifyWifiEnabledStatusIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocEventVehicleDataReadyIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventVehicleDataReadyIndMsgT_v02, vehicleAccelReadyStatus) - QMI_IDL_OFFSET8(qmiLocEventVehicleDataReadyIndMsgT_v02, vehicleAccelReadyStatus_valid)),
+  0x10,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventVehicleDataReadyIndMsgT_v02, vehicleAccelReadyStatus),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventVehicleDataReadyIndMsgT_v02, vehicleAngularRateReadyStatus) - QMI_IDL_OFFSET8(qmiLocEventVehicleDataReadyIndMsgT_v02, vehicleAngularRateReadyStatus_valid)),
+  0x11,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventVehicleDataReadyIndMsgT_v02, vehicleAngularRateReadyStatus),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventVehicleDataReadyIndMsgT_v02, vehicleOdometryReadyStatus) - QMI_IDL_OFFSET8(qmiLocEventVehicleDataReadyIndMsgT_v02, vehicleOdometryReadyStatus_valid)),
+  0x12,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventVehicleDataReadyIndMsgT_v02, vehicleOdometryReadyStatus)
+};
+
+static const uint8_t qmiLocInjectVehicleSensorDataReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectVehicleSensorDataReqMsgT_v02, accelData) - QMI_IDL_OFFSET8(qmiLocInjectVehicleSensorDataReqMsgT_v02, accelData_valid)),
+  0x10,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocInjectVehicleSensorDataReqMsgT_v02, accelData),
+  QMI_IDL_TYPE88(0, 50),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocInjectVehicleSensorDataReqMsgT_v02, angRotationData) - QMI_IDL_OFFSET16RELATIVE(qmiLocInjectVehicleSensorDataReqMsgT_v02, angRotationData_valid)),
+  0x11,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocInjectVehicleSensorDataReqMsgT_v02, angRotationData),
+  QMI_IDL_TYPE88(0, 50),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocInjectVehicleSensorDataReqMsgT_v02, odometryData) - QMI_IDL_OFFSET16RELATIVE(qmiLocInjectVehicleSensorDataReqMsgT_v02, odometryData_valid)),
+  0x12,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocInjectVehicleSensorDataReqMsgT_v02, odometryData),
+  QMI_IDL_TYPE88(0, 52),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocInjectVehicleSensorDataReqMsgT_v02, changeInTimeScales) - QMI_IDL_OFFSET16RELATIVE(qmiLocInjectVehicleSensorDataReqMsgT_v02, changeInTimeScales_valid)),
+  0x13,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocInjectVehicleSensorDataReqMsgT_v02, changeInTimeScales)
+};
+
+static const uint8_t qmiLocInjectVehicleSensorDataIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectVehicleSensorDataIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocGetAvailWwanPositionReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionReqMsgT_v02, transactionId)
+};
+
+static const uint8_t qmiLocGetAvailWwanPositionIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, transactionId) - QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, transactionId_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, transactionId),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, latitude) - QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, latitude_valid)),
+  0x11,
+   QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, latitude),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, longitude) - QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, longitude_valid)),
+  0x12,
+   QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, longitude),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, horUncCircular) - QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, horUncCircular_valid)),
+  0x13,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, horUncCircular),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, altitudeWrtEllipsoid) - QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, altitudeWrtEllipsoid_valid)),
+  0x14,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, altitudeWrtEllipsoid),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, vertUnc) - QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, vertUnc_valid)),
+  0x15,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, vertUnc),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, timestampUtc) - QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, timestampUtc_valid)),
+  0x16,
+   QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, timestampUtc),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, timeUnc) - QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, timeUnc_valid)),
+  0x17,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, timeUnc),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, horUncEllipseSemiMinor) - QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, horUncEllipseSemiMinor_valid)),
+  0x18,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, horUncEllipseSemiMinor),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, horUncEllipseSemiMajor) - QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, horUncEllipseSemiMajor_valid)),
+  0x19,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, horUncEllipseSemiMajor),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, horUncEllipseOrientAzimuth) - QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, horUncEllipseOrientAzimuth_valid)),
+  0x1A,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, horUncEllipseOrientAzimuth),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, horCircularConfidence) - QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, horCircularConfidence_valid)),
+  0x1B,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, horCircularConfidence),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, horEllipticalConfidence) - QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, horEllipticalConfidence_valid)),
+  0x1C,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, horEllipticalConfidence),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, horReliability) - QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, horReliability_valid)),
+  0x1D,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, horReliability),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, altitudeWrtMeanSeaLevel) - QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, altitudeWrtMeanSeaLevel_valid)),
+  0x1E,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, altitudeWrtMeanSeaLevel),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, vertConfidence) - QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, vertConfidence_valid)),
+  0x1F,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, vertConfidence),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, vertReliability) - QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, vertReliability_valid)),
+  0x20,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, vertReliability),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, gpsTime) - QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, gpsTime_valid)),
+  0x21,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, gpsTime),
+  QMI_IDL_TYPE88(0, 1),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, timeSrc) - QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, timeSrc_valid)),
+  0x22,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetAvailWwanPositionIndMsgT_v02, timeSrc)
+};
+
+static const uint8_t qmiLocSetPremiumServicesCfgReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetPremiumServicesCfgReqMsgT_v02, premiumServiceType),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetPremiumServicesCfgReqMsgT_v02, premiumServiceCfg)
+};
+
+static const uint8_t qmiLocSetPremiumServicesCfgIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetPremiumServicesCfgIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocSetXtraVersionCheckReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetXtraVersionCheckReqMsgT_v02, xtraVersionCheckMode)
+};
+
+static const uint8_t qmiLocSetXtraVersionCheckIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetXtraVersionCheckIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocSetGNSSConstRepConfigReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetGNSSConstRepConfigReqMsgT_v02, measReportConfig) - QMI_IDL_OFFSET8(qmiLocSetGNSSConstRepConfigReqMsgT_v02, measReportConfig_valid)),
+  0x10,
+   QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetGNSSConstRepConfigReqMsgT_v02, measReportConfig),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetGNSSConstRepConfigReqMsgT_v02, svPolyReportConfig) - QMI_IDL_OFFSET8(qmiLocSetGNSSConstRepConfigReqMsgT_v02, svPolyReportConfig_valid)),
+  0x11,
+   QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetGNSSConstRepConfigReqMsgT_v02, svPolyReportConfig)
+};
+
+static const uint8_t qmiLocSetGNSSConstRepConfigIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetGNSSConstRepConfigIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocEventGnssSvMeasInfoIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, seqNum),
+
+  0x02,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, maxMessageNum),
+
+  0x03,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, system),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, rcvrClockFrequencyInfo) - QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, rcvrClockFrequencyInfo_valid)),
+  0x10,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, rcvrClockFrequencyInfo),
+  QMI_IDL_TYPE88(0, 53),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, leapSecondInfo) - QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, leapSecondInfo_valid)),
+  0x11,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, leapSecondInfo),
+  QMI_IDL_TYPE88(0, 54),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, gpsGloInterSystemBias) - QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, gpsGloInterSystemBias_valid)),
+  0x12,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, gpsGloInterSystemBias),
+  QMI_IDL_TYPE88(0, 55),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, gpsBdsInterSystemBias) - QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, gpsBdsInterSystemBias_valid)),
+  0x13,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, gpsBdsInterSystemBias),
+  QMI_IDL_TYPE88(0, 55),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, gpsGalInterSystemBias) - QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, gpsGalInterSystemBias_valid)),
+  0x14,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, gpsGalInterSystemBias),
+  QMI_IDL_TYPE88(0, 55),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, bdsGloInterSystemBias) - QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, bdsGloInterSystemBias_valid)),
+  0x15,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, bdsGloInterSystemBias),
+  QMI_IDL_TYPE88(0, 55),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, galGloInterSystemBias) - QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, galGloInterSystemBias_valid)),
+  0x16,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, galGloInterSystemBias),
+  QMI_IDL_TYPE88(0, 55),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, galBdsInterSystemBias) - QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, galBdsInterSystemBias_valid)),
+  0x17,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, galBdsInterSystemBias),
+  QMI_IDL_TYPE88(0, 55),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, systemTime) - QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, systemTime_valid)),
+  0x18,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, systemTime),
+  QMI_IDL_TYPE88(0, 56),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, gloTime) - QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, gloTime_valid)),
+  0x19,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, gloTime),
+  QMI_IDL_TYPE88(0, 57),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, systemTimeExt) - QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, systemTimeExt_valid)),
+  0x1A,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, systemTimeExt),
+  QMI_IDL_TYPE88(0, 58),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, svMeasurement) - QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, svMeasurement_valid)),
+  0x1B,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, svMeasurement),
+  QMI_LOC_SV_MEAS_LIST_MAX_SIZE_V02,
+  QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, svMeasurement) - QMI_IDL_OFFSET8(qmiLocEventGnssSvMeasInfoIndMsgT_v02, svMeasurement_len),
+  QMI_IDL_TYPE88(0, 60),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventGnssSvMeasInfoIndMsgT_v02, numClockResets) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventGnssSvMeasInfoIndMsgT_v02, numClockResets_valid)),
+  0x1C,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventGnssSvMeasInfoIndMsgT_v02, numClockResets)
+};
+
+static const uint8_t qmiLocEventGnssSvPolyIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, gnssSvId),
+
+  0x02,
+   QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, T0),
+
+  0x03,
+   QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, svPolyFlagValid),
+
+  0x04,
+   QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, svPolyFlags),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, polyCoeffXYZ0) - QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, polyCoeffXYZ0_valid)),
+  0x10,
+  QMI_IDL_FLAGS_IS_ARRAY |  QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, polyCoeffXYZ0),
+  QMI_LOC_SV_POLY_XYZ_0_TH_ORDER_COEFF_SIZE_V02,
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, polyCoefXYZN) - QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, polyCoefXYZN_valid)),
+  0x11,
+  QMI_IDL_FLAGS_IS_ARRAY |  QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, polyCoefXYZN),
+  QMI_LOC_SV_POLY_XYZ_N_TH_ORDER_COEFF_SIZE_V02,
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, polyCoefClockBias) - QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, polyCoefClockBias_valid)),
+  0x12,
+  QMI_IDL_FLAGS_IS_ARRAY |  QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, polyCoefClockBias),
+  QMI_LOC_SV_POLY_SV_CLKBIAS_COEFF_SIZE_V02,
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, gloFrequency) - QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, gloFrequency_valid)),
+  0x13,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, gloFrequency),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, IODE) - QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, IODE_valid)),
+  0x14,
+   QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, IODE),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, enhancedIOD) - QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, enhancedIOD_valid)),
+  0x15,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, enhancedIOD),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, svPosUnc) - QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, svPosUnc_valid)),
+  0x16,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, svPosUnc),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, ionoDelay) - QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, ionoDelay_valid)),
+  0x17,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, ionoDelay),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, ionoDot) - QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, ionoDot_valid)),
+  0x18,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, ionoDot),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, sbasIonoDelay) - QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, sbasIonoDelay_valid)),
+  0x19,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, sbasIonoDelay),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, sbasIonoDot) - QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, sbasIonoDot_valid)),
+  0x1A,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, sbasIonoDot),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, tropoDelay) - QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, tropoDelay_valid)),
+  0x1B,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventGnssSvPolyIndMsgT_v02, tropoDelay),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventGnssSvPolyIndMsgT_v02, elevation) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventGnssSvPolyIndMsgT_v02, elevation_valid)),
+  0x1C,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventGnssSvPolyIndMsgT_v02, elevation),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventGnssSvPolyIndMsgT_v02, elevationDot) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventGnssSvPolyIndMsgT_v02, elevationDot_valid)),
+  0x1D,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventGnssSvPolyIndMsgT_v02, elevationDot),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventGnssSvPolyIndMsgT_v02, elenationUnc) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventGnssSvPolyIndMsgT_v02, elenationUnc_valid)),
+  0x1E,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventGnssSvPolyIndMsgT_v02, elenationUnc),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventGnssSvPolyIndMsgT_v02, velCoef) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventGnssSvPolyIndMsgT_v02, velCoef_valid)),
+  0x1F,
+  QMI_IDL_FLAGS_IS_ARRAY |  QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventGnssSvPolyIndMsgT_v02, velCoef),
+  QMI_LOC_SV_POLY_VELOCITY_COEF_SIZE_V02
+};
+
+static const uint8_t qmiLocAddGeofenceContextReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocAddGeofenceContextReqMsgT_v02, transactionId),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocAddGeofenceContextReqMsgT_v02, geofenceId) - QMI_IDL_OFFSET8(qmiLocAddGeofenceContextReqMsgT_v02, geofenceId_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocAddGeofenceContextReqMsgT_v02, geofenceId),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocAddGeofenceContextReqMsgT_v02, wifiApSsidInfo) - QMI_IDL_OFFSET8(qmiLocAddGeofenceContextReqMsgT_v02, wifiApSsidInfo_valid)),
+  0x11,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocAddGeofenceContextReqMsgT_v02, wifiApSsidInfo),
+  QMI_LOC_WIFI_AREA_ID_LIST_LENGTH_V02,
+  QMI_IDL_OFFSET8(qmiLocAddGeofenceContextReqMsgT_v02, wifiApSsidInfo) - QMI_IDL_OFFSET8(qmiLocAddGeofenceContextReqMsgT_v02, wifiApSsidInfo_len),
+  QMI_IDL_TYPE88(0, 33),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocAddGeofenceContextReqMsgT_v02, wifiApMacAddressList) - QMI_IDL_OFFSET16RELATIVE(qmiLocAddGeofenceContextReqMsgT_v02, wifiApMacAddressList_valid)),
+  0x12,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocAddGeofenceContextReqMsgT_v02, wifiApMacAddressList),
+  QMI_LOC_WIFI_AREA_ID_LIST_LENGTH_V02,
+  QMI_IDL_OFFSET16RELATIVE(qmiLocAddGeofenceContextReqMsgT_v02, wifiApMacAddressList) - QMI_IDL_OFFSET16RELATIVE(qmiLocAddGeofenceContextReqMsgT_v02, wifiApMacAddressList_len),
+  QMI_IDL_TYPE88(0, 61),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocAddGeofenceContextReqMsgT_v02, tdsCdmaCellIDList) - QMI_IDL_OFFSET16RELATIVE(qmiLocAddGeofenceContextReqMsgT_v02, tdsCdmaCellIDList_valid)),
+  0x13,
+  QMI_IDL_FLAGS_IS_ARRAY |  QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocAddGeofenceContextReqMsgT_v02, tdsCdmaCellIDList),
+  QMI_LOC_CELL_ID_LIST_LENGTH_V02,
+  QMI_IDL_TYPE88(0, 45),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocAddGeofenceContextReqMsgT_v02, wcdmaCellIDList) - QMI_IDL_OFFSET16RELATIVE(qmiLocAddGeofenceContextReqMsgT_v02, wcdmaCellIDList_valid)),
+  0x14,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocAddGeofenceContextReqMsgT_v02, wcdmaCellIDList),
+  QMI_LOC_CELL_ID_LIST_LENGTH_V02,
+  QMI_IDL_OFFSET16RELATIVE(qmiLocAddGeofenceContextReqMsgT_v02, wcdmaCellIDList) - QMI_IDL_OFFSET16RELATIVE(qmiLocAddGeofenceContextReqMsgT_v02, wcdmaCellIDList_len),
+  QMI_IDL_TYPE88(0, 44),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocAddGeofenceContextReqMsgT_v02, gsmCellIDList) - QMI_IDL_OFFSET16RELATIVE(qmiLocAddGeofenceContextReqMsgT_v02, gsmCellIDList_valid)),
+  0x15,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocAddGeofenceContextReqMsgT_v02, gsmCellIDList),
+  QMI_LOC_CELL_ID_LIST_LENGTH_V02,
+  QMI_IDL_OFFSET16RELATIVE(qmiLocAddGeofenceContextReqMsgT_v02, gsmCellIDList) - QMI_IDL_OFFSET16RELATIVE(qmiLocAddGeofenceContextReqMsgT_v02, gsmCellIDList_len),
+  QMI_IDL_TYPE88(0, 43),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocAddGeofenceContextReqMsgT_v02, iBeaconList) - QMI_IDL_OFFSET16RELATIVE(qmiLocAddGeofenceContextReqMsgT_v02, iBeaconList_valid)),
+  0x16,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocAddGeofenceContextReqMsgT_v02, iBeaconList),
+  QMI_LOC_IBEACON_LIST_LENGTH_V02,
+  QMI_IDL_OFFSET16RELATIVE(qmiLocAddGeofenceContextReqMsgT_v02, iBeaconList) - QMI_IDL_OFFSET16RELATIVE(qmiLocAddGeofenceContextReqMsgT_v02, iBeaconList_len),
+  QMI_IDL_TYPE88(0, 62)
+};
+
+static const uint8_t qmiLocAddGeofenceContextIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocAddGeofenceContextIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocAddGeofenceContextIndMsgT_v02, transactionId) - QMI_IDL_OFFSET8(qmiLocAddGeofenceContextIndMsgT_v02, transactionId_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocAddGeofenceContextIndMsgT_v02, transactionId),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocAddGeofenceContextIndMsgT_v02, geofenceId) - QMI_IDL_OFFSET8(qmiLocAddGeofenceContextIndMsgT_v02, geofenceId_valid)),
+  0x11,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocAddGeofenceContextIndMsgT_v02, geofenceId),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocAddGeofenceContextIndMsgT_v02, contextId) - QMI_IDL_OFFSET8(qmiLocAddGeofenceContextIndMsgT_v02, contextId_valid)),
+  0x12,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocAddGeofenceContextIndMsgT_v02, contextId)
+};
+
+static const uint8_t qmiLocSetGeofenceEngineContextReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineContextReqMsgT_v02, transactionId),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineContextReqMsgT_v02, utcTimeOfDay) - QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineContextReqMsgT_v02, utcTimeOfDay_valid)),
+  0x10,
+   QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineContextReqMsgT_v02, utcTimeOfDay),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineContextReqMsgT_v02, temperature) - QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineContextReqMsgT_v02, temperature_valid)),
+  0x11,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineContextReqMsgT_v02, temperature)
+};
+
+static const uint8_t qmiLocSetGeofenceEngineContextIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineContextIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineContextIndMsgT_v02, transactionId) - QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineContextIndMsgT_v02, transactionId_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSetGeofenceEngineContextIndMsgT_v02, transactionId)
+};
+
+static const uint8_t qmiLocDeleteGeofenceContextReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDeleteGeofenceContextReqMsgT_v02, transactionId),
+
+  0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDeleteGeofenceContextReqMsgT_v02, geofenceId),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocDeleteGeofenceContextReqMsgT_v02, contextId) - QMI_IDL_OFFSET8(qmiLocDeleteGeofenceContextReqMsgT_v02, contextId_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDeleteGeofenceContextReqMsgT_v02, contextId)
+};
+
+static const uint8_t qmiLocDeleteGeofenceContextIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDeleteGeofenceContextIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocDeleteGeofenceContextIndMsgT_v02, transactionId) - QMI_IDL_OFFSET8(qmiLocDeleteGeofenceContextIndMsgT_v02, transactionId_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDeleteGeofenceContextIndMsgT_v02, transactionId),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocDeleteGeofenceContextIndMsgT_v02, geofenceId) - QMI_IDL_OFFSET8(qmiLocDeleteGeofenceContextIndMsgT_v02, geofenceId_valid)),
+  0x11,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDeleteGeofenceContextIndMsgT_v02, geofenceId),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocDeleteGeofenceContextIndMsgT_v02, contextId) - QMI_IDL_OFFSET8(qmiLocDeleteGeofenceContextIndMsgT_v02, contextId_valid)),
+  0x12,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDeleteGeofenceContextIndMsgT_v02, contextId)
+};
+
+static const uint8_t qmiLocInjectGtpClientDownloadedDataReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN | QMI_IDL_FLAGS_SZ_IS_16 |   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectGtpClientDownloadedDataReqMsgT_v02, ClientDownloadedData),
+  ((QMI_LOC_MAX_GTP_WWAN_CLIENT_DOWNLOADED_DATA_LEN_V02) & 0xFF), ((QMI_LOC_MAX_GTP_WWAN_CLIENT_DOWNLOADED_DATA_LEN_V02) >> 8),
+  QMI_IDL_OFFSET8(qmiLocInjectGtpClientDownloadedDataReqMsgT_v02, ClientDownloadedData) - QMI_IDL_OFFSET8(qmiLocInjectGtpClientDownloadedDataReqMsgT_v02, ClientDownloadedData_len)
+};
+
+static const uint8_t qmiLocInjectGtpClientDownloadedDataIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectGtpClientDownloadedDataIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocGdtUploadBeginStatusReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGdtUploadBeginStatusReqMsgT_v02, serviceId),
+
+  0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGdtUploadBeginStatusReqMsgT_v02, sessionId),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x03,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGdtUploadBeginStatusReqMsgT_v02, gdtAccessStatus)
+};
+
+static const uint8_t qmiLocGdtUploadBeginStatusIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGdtUploadBeginStatusIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocGdtUploadEndReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGdtUploadEndReqMsgT_v02, serviceId),
+
+  0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGdtUploadEndReqMsgT_v02, sessionId),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x03,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGdtUploadEndReqMsgT_v02, gdtEndStatus)
+};
+
+static const uint8_t qmiLocGdtUploadEndIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGdtUploadEndIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocGtpApStatusReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGtpApStatusReqMsgT_v02, gtpApDbStatus),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGtpApStatusReqMsgT_v02, gtpApPcid64) - QMI_IDL_OFFSET8(qmiLocGtpApStatusReqMsgT_v02, gtpApPcid64_valid)),
+  0x10,
+   QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGtpApStatusReqMsgT_v02, gtpApPcid64),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGtpApStatusReqMsgT_v02, oemId) - QMI_IDL_OFFSET8(qmiLocGtpApStatusReqMsgT_v02, oemId_valid)),
+  0x11,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN | QMI_IDL_FLAGS_SZ_IS_16 |   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGtpApStatusReqMsgT_v02, oemId),
+  ((QMI_LOC_MAX_OEM_ID_LEN_V02) & 0xFF), ((QMI_LOC_MAX_OEM_ID_LEN_V02) >> 8),
+  QMI_IDL_OFFSET8(qmiLocGtpApStatusReqMsgT_v02, oemId) - QMI_IDL_OFFSET8(qmiLocGtpApStatusReqMsgT_v02, oemId_len),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocGtpApStatusReqMsgT_v02, modelId) - QMI_IDL_OFFSET16RELATIVE(qmiLocGtpApStatusReqMsgT_v02, modelId_valid)),
+  0x12,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN | QMI_IDL_FLAGS_SZ_IS_16 |   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocGtpApStatusReqMsgT_v02, modelId),
+  ((QMI_LOC_MAX_MODEL_ID_LEN_V02) & 0xFF), ((QMI_LOC_MAX_MODEL_ID_LEN_V02) >> 8),
+  QMI_IDL_OFFSET16RELATIVE(qmiLocGtpApStatusReqMsgT_v02, modelId) - QMI_IDL_OFFSET16RELATIVE(qmiLocGtpApStatusReqMsgT_v02, modelId_len)
+};
+
+static const uint8_t qmiLocGtpApStatusIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGtpApStatusIndMsgT_v02, status),
+
+  0x02,
+   QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGtpApStatusIndMsgT_v02, clientSoftwareVersion),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x03,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocGtpApStatusIndMsgT_v02, asnVersion),
+  QMI_IDL_TYPE88(0, 63)
+};
+
+static const uint8_t qmiLocGdtDownloadBeginStatusReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGdtDownloadBeginStatusReqMsgT_v02, serviceId),
+
+  0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGdtDownloadBeginStatusReqMsgT_v02, sessionId),
+
+  0x03,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGdtDownloadBeginStatusReqMsgT_v02, processingStatus),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGdtDownloadBeginStatusReqMsgT_v02, wwanDownloadFlag) - QMI_IDL_OFFSET8(qmiLocGdtDownloadBeginStatusReqMsgT_v02, wwanDownloadFlag_valid)),
+  0x10,
+   QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGdtDownloadBeginStatusReqMsgT_v02, wwanDownloadFlag),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocGdtDownloadBeginStatusReqMsgT_v02, respLocInfo) - QMI_IDL_OFFSET8(qmiLocGdtDownloadBeginStatusReqMsgT_v02, respLocInfo_valid)),
+  0x11,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN | QMI_IDL_FLAGS_SZ_IS_16 |   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGdtDownloadBeginStatusReqMsgT_v02, respLocInfo),
+  ((QMI_LOC_MAX_GTP_RLI_LEN_V02) & 0xFF), ((QMI_LOC_MAX_GTP_RLI_LEN_V02) >> 8),
+  QMI_IDL_OFFSET8(qmiLocGdtDownloadBeginStatusReqMsgT_v02, respLocInfo) - QMI_IDL_OFFSET8(qmiLocGdtDownloadBeginStatusReqMsgT_v02, respLocInfo_len),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocGdtDownloadBeginStatusReqMsgT_v02, apRemainingThrottleTime) - QMI_IDL_OFFSET16RELATIVE(qmiLocGdtDownloadBeginStatusReqMsgT_v02, apRemainingThrottleTime_valid)),
+  0x12,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocGdtDownloadBeginStatusReqMsgT_v02, apRemainingThrottleTime)
+};
+
+static const uint8_t qmiLocGdtDownloadBeginStatusIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGdtDownloadBeginStatusIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocGdtDownloadReadyStatusReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGdtDownloadReadyStatusReqMsgT_v02, serviceId),
+
+  0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGdtDownloadReadyStatusReqMsgT_v02, sessionId),
+
+  0x03,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGdtDownloadReadyStatusReqMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x04,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGdtDownloadReadyStatusReqMsgT_v02, filePath),
+  QMI_LOC_MAX_GDT_PATH_LEN_V02,
+  QMI_IDL_OFFSET8(qmiLocGdtDownloadReadyStatusReqMsgT_v02, filePath) - QMI_IDL_OFFSET8(qmiLocGdtDownloadReadyStatusReqMsgT_v02, filePath_len)
+};
+
+static const uint8_t qmiLocGdtDownloadReadyStatusIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGdtDownloadReadyStatusIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocGdtReceiveDoneStatusReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGdtReceiveDoneStatusReqMsgT_v02, serviceId),
+
+  0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGdtReceiveDoneStatusReqMsgT_v02, sessionId),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x03,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGdtReceiveDoneStatusReqMsgT_v02, status)
+};
+
+static const uint8_t qmiLocGdtReceiveDoneStatusIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGdtReceiveDoneStatusIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocGdtDownloadEndStatusReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGdtDownloadEndStatusReqMsgT_v02, serviceId),
+
+  0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGdtDownloadEndStatusReqMsgT_v02, sessionId),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x03,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGdtDownloadEndStatusReqMsgT_v02, status)
+};
+
+static const uint8_t qmiLocGdtDownloadEndStatusIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGdtDownloadEndStatusIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocStartDbtReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocStartDbtReqMsgT_v02, reqId),
+
+  0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocStartDbtReqMsgT_v02, minDistance),
+
+  0x03,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocStartDbtReqMsgT_v02, distanceType),
+
+  0x04,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocStartDbtReqMsgT_v02, needOriginLocation),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocStartDbtReqMsgT_v02, maxLatency) - QMI_IDL_OFFSET8(qmiLocStartDbtReqMsgT_v02, maxLatency_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocStartDbtReqMsgT_v02, maxLatency),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocStartDbtReqMsgT_v02, usageType) - QMI_IDL_OFFSET8(qmiLocStartDbtReqMsgT_v02, usageType_valid)),
+  0x11,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocStartDbtReqMsgT_v02, usageType)
+};
+
+static const uint8_t qmiLocStartDbtIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocStartDbtIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocStartDbtIndMsgT_v02, reqId) - QMI_IDL_OFFSET8(qmiLocStartDbtIndMsgT_v02, reqId_valid)),
+  0x10,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocStartDbtIndMsgT_v02, reqId)
+};
+
+static const uint8_t qmiLocStopDbtReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocStopDbtReqMsgT_v02, reqId)
+};
+
+static const uint8_t qmiLocStopDbtIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocStopDbtIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocStopDbtIndMsgT_v02, reqId) - QMI_IDL_OFFSET8(qmiLocStopDbtIndMsgT_v02, reqId_valid)),
+  0x10,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocStopDbtIndMsgT_v02, reqId)
+};
+
+static const uint8_t qmiLocEventDbtPositionReportIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventDbtPositionReportIndMsgT_v02, reqId),
+
+  0x02,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocEventDbtPositionReportIndMsgT_v02, dbtPosition),
+  QMI_IDL_TYPE88(0, 64),
+
+  0x03,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventDbtPositionReportIndMsgT_v02, positionType),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventDbtPositionReportIndMsgT_v02, headingUnc) - QMI_IDL_OFFSET8(qmiLocEventDbtPositionReportIndMsgT_v02, headingUnc_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventDbtPositionReportIndMsgT_v02, headingUnc),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventDbtPositionReportIndMsgT_v02, speedUnc) - QMI_IDL_OFFSET8(qmiLocEventDbtPositionReportIndMsgT_v02, speedUnc_valid)),
+  0x11,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventDbtPositionReportIndMsgT_v02, speedUnc),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventDbtPositionReportIndMsgT_v02, horConfidence) - QMI_IDL_OFFSET8(qmiLocEventDbtPositionReportIndMsgT_v02, horConfidence_valid)),
+  0x12,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventDbtPositionReportIndMsgT_v02, horConfidence),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventDbtPositionReportIndMsgT_v02, vertConfidence) - QMI_IDL_OFFSET8(qmiLocEventDbtPositionReportIndMsgT_v02, vertConfidence_valid)),
+  0x13,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventDbtPositionReportIndMsgT_v02, vertConfidence),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventDbtPositionReportIndMsgT_v02, DOP) - QMI_IDL_OFFSET8(qmiLocEventDbtPositionReportIndMsgT_v02, DOP_valid)),
+  0x14,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocEventDbtPositionReportIndMsgT_v02, DOP),
+  QMI_IDL_TYPE88(0, 2),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventDbtPositionReportIndMsgT_v02, gnssSvUsedList) - QMI_IDL_OFFSET8(qmiLocEventDbtPositionReportIndMsgT_v02, gnssSvUsedList_valid)),
+  0x15,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventDbtPositionReportIndMsgT_v02, gnssSvUsedList),
+  QMI_LOC_MAX_SV_USED_LIST_LENGTH_V02,
+  QMI_IDL_OFFSET8(qmiLocEventDbtPositionReportIndMsgT_v02, gnssSvUsedList) - QMI_IDL_OFFSET8(qmiLocEventDbtPositionReportIndMsgT_v02, gnssSvUsedList_len),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocEventDbtPositionReportIndMsgT_v02, positionSrc) - QMI_IDL_OFFSET16RELATIVE(qmiLocEventDbtPositionReportIndMsgT_v02, positionSrc_valid)),
+  0x16,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocEventDbtPositionReportIndMsgT_v02, positionSrc)
+};
+
+static const uint8_t qmiLocEventDbtSessionStatusIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventDbtSessionStatusIndMsgT_v02, dbtSessionStatus),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocEventDbtSessionStatusIndMsgT_v02, reqId) - QMI_IDL_OFFSET8(qmiLocEventDbtSessionStatusIndMsgT_v02, reqId_valid)),
+  0x10,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventDbtSessionStatusIndMsgT_v02, reqId)
+};
+
+static const uint8_t qmiLocSecureGetAvailablePositionReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSecureGetAvailablePositionReqMsgT_v02, secureLocDataMode),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x02,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN | QMI_IDL_FLAGS_SZ_IS_16 |   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSecureGetAvailablePositionReqMsgT_v02, qmilocSecureGetAvailablePositionRequestData),
+  ((QMI_LOC_SECURE_GET_AVAILABLE_POS_REQUEST_ENCRYPTED_MAX_V02) & 0xFF), ((QMI_LOC_SECURE_GET_AVAILABLE_POS_REQUEST_ENCRYPTED_MAX_V02) >> 8),
+  QMI_IDL_OFFSET8(qmiLocSecureGetAvailablePositionReqMsgT_v02, qmilocSecureGetAvailablePositionRequestData) - QMI_IDL_OFFSET8(qmiLocSecureGetAvailablePositionReqMsgT_v02, qmilocSecureGetAvailablePositionRequestData_len)
+};
+
+static const uint8_t qmiLocSecureGetAvailablePositionIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSecureGetAvailablePositionIndMsgT_v02, sessionStatus),
+
+  0x02,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSecureGetAvailablePositionIndMsgT_v02, secureLocDataMode),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocSecureGetAvailablePositionIndMsgT_v02, qmilocSecureGetAvailablePositionInd) - QMI_IDL_OFFSET8(qmiLocSecureGetAvailablePositionIndMsgT_v02, qmilocSecureGetAvailablePositionInd_valid)),
+  0x10,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN | QMI_IDL_FLAGS_SZ_IS_16 |   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocSecureGetAvailablePositionIndMsgT_v02, qmilocSecureGetAvailablePositionInd),
+  ((QMI_LOC_SECURE_GET_AVAILABLE_POSITION_IND_ENCRYPTED_MAX_V02) & 0xFF), ((QMI_LOC_SECURE_GET_AVAILABLE_POSITION_IND_ENCRYPTED_MAX_V02) >> 8),
+  QMI_IDL_OFFSET8(qmiLocSecureGetAvailablePositionIndMsgT_v02, qmilocSecureGetAvailablePositionInd) - QMI_IDL_OFFSET8(qmiLocSecureGetAvailablePositionIndMsgT_v02, qmilocSecureGetAvailablePositionInd_len)
+};
+
+static const uint8_t qmiLocInjectApCacheDataReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectApCacheDataReqMsgT_v02, versionNumber),
+
+  0x02,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectApCacheDataReqMsgT_v02, partNumber),
+
+  0x03,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectApCacheDataReqMsgT_v02, totalParts),
+
+  0x04,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocInjectApCacheDataReqMsgT_v02, apCacheData),
+  QMI_LOC_APCACHE_DATA_MAX_SAMPLES_V02,
+  QMI_IDL_OFFSET8(qmiLocInjectApCacheDataReqMsgT_v02, apCacheData) - QMI_IDL_OFFSET8(qmiLocInjectApCacheDataReqMsgT_v02, apCacheData_len),
+  QMI_IDL_TYPE88(0, 65),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocInjectApCacheDataReqMsgT_v02, apCacheHepeRelData) - QMI_IDL_OFFSET16RELATIVE(qmiLocInjectApCacheDataReqMsgT_v02, apCacheHepeRelData_valid)),
+  0x10,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocInjectApCacheDataReqMsgT_v02, apCacheHepeRelData),
+  QMI_LOC_APCACHE_DATA_MAX_SAMPLES_V02,
+  QMI_IDL_OFFSET16RELATIVE(qmiLocInjectApCacheDataReqMsgT_v02, apCacheHepeRelData) - QMI_IDL_OFFSET16RELATIVE(qmiLocInjectApCacheDataReqMsgT_v02, apCacheHepeRelData_len),
+  QMI_IDL_TYPE88(0, 66)
+};
+
+static const uint8_t qmiLocInjectApCacheDataIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectApCacheDataIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectApCacheDataIndMsgT_v02, apCacheSize) - QMI_IDL_OFFSET8(qmiLocInjectApCacheDataIndMsgT_v02, apCacheSize_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectApCacheDataIndMsgT_v02, apCacheSize),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectApCacheDataIndMsgT_v02, apDoNotCacheSize) - QMI_IDL_OFFSET8(qmiLocInjectApCacheDataIndMsgT_v02, apDoNotCacheSize_valid)),
+  0x11,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectApCacheDataIndMsgT_v02, apDoNotCacheSize),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectApCacheDataIndMsgT_v02, apCacheHits) - QMI_IDL_OFFSET8(qmiLocInjectApCacheDataIndMsgT_v02, apCacheHits_valid)),
+  0x12,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectApCacheDataIndMsgT_v02, apCacheHits),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectApCacheDataIndMsgT_v02, apDoNotCacheHits) - QMI_IDL_OFFSET8(qmiLocInjectApCacheDataIndMsgT_v02, apDoNotCacheHits_valid)),
+  0x13,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectApCacheDataIndMsgT_v02, apDoNotCacheHits),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectApCacheDataIndMsgT_v02, unknownAps) - QMI_IDL_OFFSET8(qmiLocInjectApCacheDataIndMsgT_v02, unknownAps_valid)),
+  0x14,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectApCacheDataIndMsgT_v02, unknownAps),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectApCacheDataIndMsgT_v02, asyncScans) - QMI_IDL_OFFSET8(qmiLocInjectApCacheDataIndMsgT_v02, asyncScans_valid)),
+  0x15,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectApCacheDataIndMsgT_v02, asyncScans),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectApCacheDataIndMsgT_v02, asyncFixes) - QMI_IDL_OFFSET8(qmiLocInjectApCacheDataIndMsgT_v02, asyncFixes_valid)),
+  0x16,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectApCacheDataIndMsgT_v02, asyncFixes),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectApCacheDataIndMsgT_v02, syncScans) - QMI_IDL_OFFSET8(qmiLocInjectApCacheDataIndMsgT_v02, syncScans_valid)),
+  0x17,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectApCacheDataIndMsgT_v02, syncScans),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectApCacheDataIndMsgT_v02, syncFixes) - QMI_IDL_OFFSET8(qmiLocInjectApCacheDataIndMsgT_v02, syncFixes_valid)),
+  0x18,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectApCacheDataIndMsgT_v02, syncFixes)
+};
+
+static const uint8_t qmiLocInjectApDoNotCacheDataReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectApDoNotCacheDataReqMsgT_v02, versionNumber),
+
+  0x02,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectApDoNotCacheDataReqMsgT_v02, partNumber),
+
+  0x03,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectApDoNotCacheDataReqMsgT_v02, totalParts),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x04,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocInjectApDoNotCacheDataReqMsgT_v02, apDoNotCacheData),
+  QMI_LOC_APCACHE_DATA_MAX_SAMPLES_V02,
+  QMI_IDL_OFFSET8(qmiLocInjectApDoNotCacheDataReqMsgT_v02, apDoNotCacheData) - QMI_IDL_OFFSET8(qmiLocInjectApDoNotCacheDataReqMsgT_v02, apDoNotCacheData_len),
+  QMI_IDL_TYPE88(0, 67)
+};
+
+static const uint8_t qmiLocInjectApDoNotCacheDataIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectApDoNotCacheDataIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocEventBatchingStatusIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocEventBatchingStatusIndMsgT_v02, batchingStatus)
+};
+
+static const uint8_t qmiLocQueryAonConfigReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocQueryAonConfigReqMsgT_v02, transactionId)
+};
+
+static const uint8_t qmiLocQueryAonConfigIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocQueryAonConfigIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocQueryAonConfigIndMsgT_v02, transactionId) - QMI_IDL_OFFSET8(qmiLocQueryAonConfigIndMsgT_v02, transactionId_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocQueryAonConfigIndMsgT_v02, transactionId),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocQueryAonConfigIndMsgT_v02, aonCapability) - QMI_IDL_OFFSET8(qmiLocQueryAonConfigIndMsgT_v02, aonCapability_valid)),
+  0x11,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocQueryAonConfigIndMsgT_v02, aonCapability)
+};
+
+static const uint8_t qmiLocDeleteGNSSServiceDataReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDeleteGNSSServiceDataReqMsgT_v02, deleteAllFlag),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocDeleteGNSSServiceDataReqMsgT_v02, deleteClockInfoMask) - QMI_IDL_OFFSET8(qmiLocDeleteGNSSServiceDataReqMsgT_v02, deleteClockInfoMask_valid)),
+  0x10,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDeleteGNSSServiceDataReqMsgT_v02, deleteClockInfoMask),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocDeleteGNSSServiceDataReqMsgT_v02, deleteCellDbDataMask) - QMI_IDL_OFFSET8(qmiLocDeleteGNSSServiceDataReqMsgT_v02, deleteCellDbDataMask_valid)),
+  0x11,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDeleteGNSSServiceDataReqMsgT_v02, deleteCellDbDataMask),
+
+  QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocDeleteGNSSServiceDataReqMsgT_v02, deleteCommonDataMask) - QMI_IDL_OFFSET8(qmiLocDeleteGNSSServiceDataReqMsgT_v02, deleteCommonDataMask_valid)),
+  0x12,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDeleteGNSSServiceDataReqMsgT_v02, deleteCommonDataMask),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocDeleteGNSSServiceDataReqMsgT_v02, deleteSatelliteData) - QMI_IDL_OFFSET8(qmiLocDeleteGNSSServiceDataReqMsgT_v02, deleteSatelliteData_valid)),
+  0x13,
+   QMI_IDL_AGGREGATE,
+  QMI_IDL_OFFSET8(qmiLocDeleteGNSSServiceDataReqMsgT_v02, deleteSatelliteData),
+  QMI_IDL_TYPE88(0, 68)
+};
+
+static const uint8_t qmiLocDeleteGNSSServiceDataIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocDeleteGNSSServiceDataIndMsgT_v02, status)
+};
+
+static const uint8_t qmiLocInjectXtraDataReqMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectXtraDataReqMsgT_v02, totalSize),
+
+  0x02,
+   QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectXtraDataReqMsgT_v02, totalParts),
+
+  0x03,
+   QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectXtraDataReqMsgT_v02, partNum),
+
+  0x04,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN | QMI_IDL_FLAGS_SZ_IS_16 |   QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectXtraDataReqMsgT_v02, partData),
+  ((QMI_LOC_MAX_XTRA_PART_LEN_V02) & 0xFF), ((QMI_LOC_MAX_XTRA_PART_LEN_V02) >> 8),
+  QMI_IDL_OFFSET8(qmiLocInjectXtraDataReqMsgT_v02, partData) - QMI_IDL_OFFSET8(qmiLocInjectXtraDataReqMsgT_v02, partData_len),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET16RELATIVE(qmiLocInjectXtraDataReqMsgT_v02, formatType) - QMI_IDL_OFFSET16RELATIVE(qmiLocInjectXtraDataReqMsgT_v02, formatType_valid)),
+  0x10,
+   QMI_IDL_FLAGS_OFFSET_IS_16 | QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET16ARRAY(qmiLocInjectXtraDataReqMsgT_v02, formatType)
+};
+
+static const uint8_t qmiLocInjectXtraDataIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectXtraDataIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | QMI_IDL_TLV_FLAGS_OPTIONAL | (QMI_IDL_OFFSET8(qmiLocInjectXtraDataIndMsgT_v02, partNum) - QMI_IDL_OFFSET8(qmiLocInjectXtraDataIndMsgT_v02, partNum_valid)),
+  0x10,
+   QMI_IDL_GENERIC_2_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectXtraDataIndMsgT_v02, partNum)
+};
+
+static const uint8_t qmiLocInjectXtraPcidReqMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_8_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectXtraPcidReqMsgT_v02, xtraPcid)
+};
+
+static const uint8_t qmiLocInjectXtraPcidIndMsgT_data_v02[] = {
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocInjectXtraPcidIndMsgT_v02, status)
+};
+
+/*
+ * qmiLocGetSupportedFeatureReqMsgT is empty
+ * static const uint8_t qmiLocGetSupportedFeatureReqMsgT_data_v02[] = {
+ * };
+ */
+
+static const uint8_t qmiLocGetSupportedFeatureIndMsgT_data_v02[] = {
+  0x01,
+   QMI_IDL_GENERIC_4_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetSupportedFeatureIndMsgT_v02, status),
+
+  QMI_IDL_TLV_FLAGS_LAST_TLV | 0x02,
+  QMI_IDL_FLAGS_IS_ARRAY | QMI_IDL_FLAGS_IS_VARIABLE_LEN |  QMI_IDL_GENERIC_1_BYTE,
+  QMI_IDL_OFFSET8(qmiLocGetSupportedFeatureIndMsgT_v02, feature),
+  QMI_LOC_SUPPORTED_FEATURE_LENGTH_V02,
+  QMI_IDL_OFFSET8(qmiLocGetSupportedFeatureIndMsgT_v02, feature) - QMI_IDL_OFFSET8(qmiLocGetSupportedFeatureIndMsgT_v02, feature_len)
+};
+
+/* Type Table */
+static const qmi_idl_type_table_entry  loc_type_table_v02[] = {
+  {sizeof(qmiLocApplicationIdStructT_v02), qmiLocApplicationIdStructT_data_v02},
+  {sizeof(qmiLocGPSTimeStructT_v02), qmiLocGPSTimeStructT_data_v02},
+  {sizeof(qmiLocDOPStructT_v02), qmiLocDOPStructT_data_v02},
+  {sizeof(qmiLocSensorUsageIndicatorStructT_v02), qmiLocSensorUsageIndicatorStructT_data_v02},
+  {sizeof(qmiLocSvInfoStructT_v02), qmiLocSvInfoStructT_data_v02},
+  {sizeof(qmiLocNiVxNotifyVerifyStructT_v02), qmiLocNiVxNotifyVerifyStructT_data_v02},
+  {sizeof(qmiLocNiSuplFormattedStringStructT_v02), qmiLocNiSuplFormattedStringStructT_data_v02},
+  {sizeof(qmiLocNiSuplQopStructT_v02), qmiLocNiSuplQopStructT_data_v02},
+  {sizeof(qmiLocIpV4AddrStructType_v02), qmiLocIpV4AddrStructType_data_v02},
+  {sizeof(qmiLocIpV6AddrStructType_v02), qmiLocIpV6AddrStructType_data_v02},
+  {sizeof(qmiLocNiSuplServerInfoStructT_v02), qmiLocNiSuplServerInfoStructT_data_v02},
+  {sizeof(qmiLocNiSuplNotifyVerifyStructT_v02), qmiLocNiSuplNotifyVerifyStructT_data_v02},
+  {sizeof(qmiLocNiUmtsCpCodedStringStructT_v02), qmiLocNiUmtsCpCodedStringStructT_data_v02},
+  {sizeof(qmiLocNiUmtsCpNotifyVerifyStructT_v02), qmiLocNiUmtsCpNotifyVerifyStructT_data_v02},
+  {sizeof(qmiLocNiVxServiceInteractionStructT_v02), qmiLocNiVxServiceInteractionStructT_data_v02},
+  {sizeof(qmiLocNiSuplVer2ExtStructT_v02), qmiLocNiSuplVer2ExtStructT_data_v02},
+  {sizeof(qmiLocEmergencyNotificationStructT_v02), qmiLocEmergencyNotificationStructT_data_v02},
+  {sizeof(qmiLocAssistanceServerUrlStructT_v02), qmiLocAssistanceServerUrlStructT_data_v02},
+  {sizeof(qmiLocTimeServerListStructT_v02), qmiLocTimeServerListStructT_data_v02},
+  {sizeof(qmiLocPredictedOrbitsAllowedSizesStructT_v02), qmiLocPredictedOrbitsAllowedSizesStructT_data_v02},
+  {sizeof(qmiLocPredictedOrbitsServerListStructT_v02), qmiLocPredictedOrbitsServerListStructT_data_v02},
+  {sizeof(qmiLocSensorControlConfigSamplingSpecStructT_v02), qmiLocSensorControlConfigSamplingSpecStructT_data_v02},
+  {sizeof(qmiLocSensorReadyStatusStructT_v02), qmiLocSensorReadyStatusStructT_data_v02},
+  {sizeof(qmiLocGeofencePositionStructT_v02), qmiLocGeofencePositionStructT_data_v02},
+  {sizeof(qmiLocGeofenceIdContinuousStructT_v02), qmiLocGeofenceIdContinuousStructT_data_v02},
+  {sizeof(qmiLocPredictedOrbitsDataValidityStructT_v02), qmiLocPredictedOrbitsDataValidityStructT_data_v02},
+  {sizeof(qmiLocAltitudeSrcInfoStructT_v02), qmiLocAltitudeSrcInfoStructT_data_v02},
+  {sizeof(qmiLocDeleteSvInfoStructT_v02), qmiLocDeleteSvInfoStructT_data_v02},
+  {sizeof(qmiLocDeleteBDSSvInfoStructT_v02), qmiLocDeleteBDSSvInfoStructT_data_v02},
+  {sizeof(qmiLocDeleteGALSvInfoStructT_v02), qmiLocDeleteGALSvInfoStructT_data_v02},
+  {sizeof(qmiLocWifiFixTimeStructT_v02), qmiLocWifiFixTimeStructT_data_v02},
+  {sizeof(qmiLocWifiFixPosStructT_v02), qmiLocWifiFixPosStructT_data_v02},
+  {sizeof(qmiLocWifiApInfoStructT_v02), qmiLocWifiApInfoStructT_data_v02},
+  {sizeof(qmiLocWifiApSsidStructT_v02), qmiLocWifiApSsidStructT_data_v02},
+  {sizeof(qmiLoc3AxisSensorSampleStructT_v02), qmiLoc3AxisSensorSampleStructT_data_v02},
+  {sizeof(qmiLoc3AxisSensorSampleListStructT_v02), qmiLoc3AxisSensorSampleListStructT_data_v02},
+  {sizeof(qmiLocSensorTemperatureSampleStructT_v02), qmiLocSensorTemperatureSampleStructT_data_v02},
+  {sizeof(qmiLocSensorTemperatureSampleListStructT_v02), qmiLocSensorTemperatureSampleListStructT_data_v02},
+  {sizeof(qmiLocApnProfilesStructT_v02), qmiLocApnProfilesStructT_data_v02},
+  {sizeof(qmiLocCircularGeofenceArgsStructT_v02), qmiLocCircularGeofenceArgsStructT_data_v02},
+  {sizeof(qmiLocGeofenceMotionStateConfigStructT_v02), qmiLocGeofenceMotionStateConfigStructT_data_v02},
+  {sizeof(qmiLocTimeZoneStructT_v02), qmiLocTimeZoneStructT_data_v02},
+  {sizeof(qmiLocMotionDataStructT_v02), qmiLocMotionDataStructT_data_v02},
+  {sizeof(qmiLocGSMCellIdStructT_v02), qmiLocGSMCellIdStructT_data_v02},
+  {sizeof(qmiLocWCDMACellIdStructT_v02), qmiLocWCDMACellIdStructT_data_v02},
+  {sizeof(qmiLocTDSCDMACellIdStructT_v02), qmiLocTDSCDMACellIdStructT_data_v02},
+  {sizeof(qmiLocBatchedReportStructT_v02), qmiLocBatchedReportStructT_data_v02},
+  {sizeof(qmiLocWifiApDataStructT_v02), qmiLocWifiApDataStructT_data_v02},
+  {sizeof(qmiLocWifiApAdditionalDataStructT_v02), qmiLocWifiApAdditionalDataStructT_data_v02},
+  {sizeof(qmiLocVehicleSensorSampleStructT_v02), qmiLocVehicleSensorSampleStructT_data_v02},
+  {sizeof(qmiLocVehicleSensorSampleListStructType_v02), qmiLocVehicleSensorSampleListStructType_data_v02},
+  {sizeof(qmiLocVehicleOdometrySampleStructT_v02), qmiLocVehicleOdometrySampleStructT_data_v02},
+  {sizeof(qmiLocVehicleOdometrySampleListStructT_v02), qmiLocVehicleOdometrySampleListStructT_data_v02},
+  {sizeof(qmiLocRcvrClockFrequencyInfoStructT_v02), qmiLocRcvrClockFrequencyInfoStructT_data_v02},
+  {sizeof(qmiLocLeapSecondInfoStructT_v02), qmiLocLeapSecondInfoStructT_data_v02},
+  {sizeof(qmiLocInterSystemBiasStructT_v02), qmiLocInterSystemBiasStructT_data_v02},
+  {sizeof(qmiLocGnssTimeStructT_v02), qmiLocGnssTimeStructT_data_v02},
+  {sizeof(qmiLocGloTimeStructT_v02), qmiLocGloTimeStructT_data_v02},
+  {sizeof(qmiLocGnssTimeExtStructT_v02), qmiLocGnssTimeExtStructT_data_v02},
+  {sizeof(qmiLocSVTimeSpeedStructT_v02), qmiLocSVTimeSpeedStructT_data_v02},
+  {sizeof(qmiLocSVMeasurementStructT_v02), qmiLocSVMeasurementStructT_data_v02},
+  {sizeof(qmiLocWifiApMacAddressStructT_v02), qmiLocWifiApMacAddressStructT_data_v02},
+  {sizeof(qmiLocIBeaconIdStructT_v02), qmiLocIBeaconIdStructT_data_v02},
+  {sizeof(qmiLocGtpAsnVerStructT_v02), qmiLocGtpAsnVerStructT_data_v02},
+  {sizeof(qmiLocDbtPositionStructT_v02), qmiLocDbtPositionStructT_data_v02},
+  {sizeof(qmiLocApCacheStructT_v02), qmiLocApCacheStructT_data_v02},
+  {sizeof(qmiLocApCacheHepeRelStructT_v02), qmiLocApCacheHepeRelStructT_data_v02},
+  {sizeof(qmiLocApDoNotCacheStructT_v02), qmiLocApDoNotCacheStructT_data_v02},
+  {sizeof(qmiLocDeleteSatelliteDataStructT_v02), qmiLocDeleteSatelliteDataStructT_data_v02}
+};
+
+/* Message Table */
+static const qmi_idl_message_table_entry loc_message_table_v02[] = {
+  {sizeof(qmiLocGenRespMsgT_v02), qmiLocGenRespMsgT_data_v02},
+  {sizeof(qmiLocInformClientRevisionReqMsgT_v02), qmiLocInformClientRevisionReqMsgT_data_v02},
+  {sizeof(qmiLocRegEventsReqMsgT_v02), qmiLocRegEventsReqMsgT_data_v02},
+  {sizeof(qmiLocStartReqMsgT_v02), qmiLocStartReqMsgT_data_v02},
+  {sizeof(qmiLocStopReqMsgT_v02), qmiLocStopReqMsgT_data_v02},
+  {sizeof(qmiLocEventPositionReportIndMsgT_v02), qmiLocEventPositionReportIndMsgT_data_v02},
+  {sizeof(qmiLocEventGnssSvInfoIndMsgT_v02), qmiLocEventGnssSvInfoIndMsgT_data_v02},
+  {sizeof(qmiLocEventNmeaIndMsgT_v02), qmiLocEventNmeaIndMsgT_data_v02},
+  {sizeof(qmiLocEventNiNotifyVerifyReqIndMsgT_v02), qmiLocEventNiNotifyVerifyReqIndMsgT_data_v02},
+  {sizeof(qmiLocEventInjectTimeReqIndMsgT_v02), qmiLocEventInjectTimeReqIndMsgT_data_v02},
+  {sizeof(qmiLocEventInjectPredictedOrbitsReqIndMsgT_v02), qmiLocEventInjectPredictedOrbitsReqIndMsgT_data_v02},
+  {sizeof(qmiLocEventInjectPositionReqIndMsgT_v02), qmiLocEventInjectPositionReqIndMsgT_data_v02},
+  {sizeof(qmiLocEventEngineStateIndMsgT_v02), qmiLocEventEngineStateIndMsgT_data_v02},
+  {sizeof(qmiLocEventFixSessionStateIndMsgT_v02), qmiLocEventFixSessionStateIndMsgT_data_v02},
+  {sizeof(qmiLocEventWifiReqIndMsgT_v02), qmiLocEventWifiReqIndMsgT_data_v02},
+  {sizeof(qmiLocEventSensorStreamingReadyStatusIndMsgT_v02), qmiLocEventSensorStreamingReadyStatusIndMsgT_data_v02},
+  {sizeof(qmiLocEventTimeSyncReqIndMsgT_v02), qmiLocEventTimeSyncReqIndMsgT_data_v02},
+  {sizeof(qmiLocEventSetSpiStreamingReportIndMsgT_v02), qmiLocEventSetSpiStreamingReportIndMsgT_data_v02},
+  {sizeof(qmiLocEventLocationServerConnectionReqIndMsgT_v02), qmiLocEventLocationServerConnectionReqIndMsgT_data_v02},
+  {sizeof(qmiLocEventNiGeofenceNotificationIndMsgT_v02), qmiLocEventNiGeofenceNotificationIndMsgT_data_v02},
+  {sizeof(qmiLocEventGeofenceGenAlertIndMsgT_v02), qmiLocEventGeofenceGenAlertIndMsgT_data_v02},
+  {sizeof(qmiLocEventGeofenceBreachIndMsgT_v02), qmiLocEventGeofenceBreachIndMsgT_data_v02},
+  {sizeof(qmiLocEventPedometerControlIndMsgT_v02), qmiLocEventPedometerControlIndMsgT_data_v02},
+  {sizeof(qmiLocEventMotionDataControlIndMsgT_v02), qmiLocEventMotionDataControlIndMsgT_data_v02},
+  {sizeof(qmiLocEventGeofenceBatchedBreachIndMsgT_v02), qmiLocEventGeofenceBatchedBreachIndMsgT_data_v02},
+  {sizeof(qmiLocEventGeofenceProximityIndMsgT_v02), qmiLocEventGeofenceProximityIndMsgT_data_v02},
+  {sizeof(qmiLocEventGeofenceBatchedDwellIndMsgT_v02), qmiLocEventGeofenceBatchedDwellIndMsgT_data_v02},
+  {sizeof(qmiLocEventGdtUploadBeginStatusReqIndMsgT_v02), qmiLocEventGdtUploadBeginStatusReqIndMsgT_data_v02},
+  {sizeof(qmiLocEventGdtUploadEndReqIndMsgT_v02), qmiLocEventGdtUploadEndReqIndMsgT_data_v02},
+  {sizeof(qmiLocEventGdtDownloadBeginReqIndMsgT_v02), qmiLocEventGdtDownloadBeginReqIndMsgT_data_v02},
+  {sizeof(qmiLocEventGdtReceiveDoneIndMsgT_v02), qmiLocEventGdtReceiveDoneIndMsgT_data_v02},
+  {sizeof(qmiLocEventGdtDownloadEndReqIndMsgT_v02), qmiLocEventGdtDownloadEndReqIndMsgT_data_v02},
+  {sizeof(qmiLocGetServiceRevisionReqMsgT_v02), 0},
+  {sizeof(qmiLocGetServiceRevisionIndMsgT_v02), qmiLocGetServiceRevisionIndMsgT_data_v02},
+  {sizeof(qmiLocGetFixCriteriaReqMsgT_v02), 0},
+  {sizeof(qmiLocGetFixCriteriaIndMsgT_v02), qmiLocGetFixCriteriaIndMsgT_data_v02},
+  {sizeof(qmiLocNiUserRespReqMsgT_v02), qmiLocNiUserRespReqMsgT_data_v02},
+  {sizeof(qmiLocNiUserRespIndMsgT_v02), qmiLocNiUserRespIndMsgT_data_v02},
+  {sizeof(qmiLocInjectPredictedOrbitsDataReqMsgT_v02), qmiLocInjectPredictedOrbitsDataReqMsgT_data_v02},
+  {sizeof(qmiLocInjectPredictedOrbitsDataIndMsgT_v02), qmiLocInjectPredictedOrbitsDataIndMsgT_data_v02},
+  {sizeof(qmiLocGetPredictedOrbitsDataSourceReqMsgT_v02), 0},
+  {sizeof(qmiLocGetPredictedOrbitsDataSourceIndMsgT_v02), qmiLocGetPredictedOrbitsDataSourceIndMsgT_data_v02},
+  {sizeof(qmiLocGetPredictedOrbitsDataValidityReqMsgT_v02), 0},
+  {sizeof(qmiLocGetPredictedOrbitsDataValidityIndMsgT_v02), qmiLocGetPredictedOrbitsDataValidityIndMsgT_data_v02},
+  {sizeof(qmiLocInjectUtcTimeReqMsgT_v02), qmiLocInjectUtcTimeReqMsgT_data_v02},
+  {sizeof(qmiLocInjectUtcTimeIndMsgT_v02), qmiLocInjectUtcTimeIndMsgT_data_v02},
+  {sizeof(qmiLocInjectPositionReqMsgT_v02), qmiLocInjectPositionReqMsgT_data_v02},
+  {sizeof(qmiLocInjectPositionIndMsgT_v02), qmiLocInjectPositionIndMsgT_data_v02},
+  {sizeof(qmiLocSetEngineLockReqMsgT_v02), qmiLocSetEngineLockReqMsgT_data_v02},
+  {sizeof(qmiLocSetEngineLockIndMsgT_v02), qmiLocSetEngineLockIndMsgT_data_v02},
+  {sizeof(qmiLocGetEngineLockReqMsgT_v02), 0},
+  {sizeof(qmiLocGetEngineLockIndMsgT_v02), qmiLocGetEngineLockIndMsgT_data_v02},
+  {sizeof(qmiLocSetSbasConfigReqMsgT_v02), qmiLocSetSbasConfigReqMsgT_data_v02},
+  {sizeof(qmiLocSetSbasConfigIndMsgT_v02), qmiLocSetSbasConfigIndMsgT_data_v02},
+  {sizeof(qmiLocGetSbasConfigReqMsgT_v02), 0},
+  {sizeof(qmiLocGetSbasConfigIndMsgT_v02), qmiLocGetSbasConfigIndMsgT_data_v02},
+  {sizeof(qmiLocSetNmeaTypesReqMsgT_v02), qmiLocSetNmeaTypesReqMsgT_data_v02},
+  {sizeof(qmiLocSetNmeaTypesIndMsgT_v02), qmiLocSetNmeaTypesIndMsgT_data_v02},
+  {sizeof(qmiLocGetNmeaTypesReqMsgT_v02), 0},
+  {sizeof(qmiLocGetNmeaTypesIndMsgT_v02), qmiLocGetNmeaTypesIndMsgT_data_v02},
+  {sizeof(qmiLocSetLowPowerModeReqMsgT_v02), qmiLocSetLowPowerModeReqMsgT_data_v02},
+  {sizeof(qmiLocSetLowPowerModeIndMsgT_v02), qmiLocSetLowPowerModeIndMsgT_data_v02},
+  {sizeof(qmiLocGetLowPowerModeReqMsgT_v02), 0},
+  {sizeof(qmiLocGetLowPowerModeIndMsgT_v02), qmiLocGetLowPowerModeIndMsgT_data_v02},
+  {sizeof(qmiLocSetServerReqMsgT_v02), qmiLocSetServerReqMsgT_data_v02},
+  {sizeof(qmiLocSetServerIndMsgT_v02), qmiLocSetServerIndMsgT_data_v02},
+  {sizeof(qmiLocGetServerReqMsgT_v02), qmiLocGetServerReqMsgT_data_v02},
+  {sizeof(qmiLocGetServerIndMsgT_v02), qmiLocGetServerIndMsgT_data_v02},
+  {sizeof(qmiLocDeleteAssistDataReqMsgT_v02), qmiLocDeleteAssistDataReqMsgT_data_v02},
+  {sizeof(qmiLocDeleteAssistDataIndMsgT_v02), qmiLocDeleteAssistDataIndMsgT_data_v02},
+  {sizeof(qmiLocSetXtraTSessionControlReqMsgT_v02), qmiLocSetXtraTSessionControlReqMsgT_data_v02},
+  {sizeof(qmiLocSetXtraTSessionControlIndMsgT_v02), qmiLocSetXtraTSessionControlIndMsgT_data_v02},
+  {sizeof(qmiLocGetXtraTSessionControlReqMsgT_v02), 0},
+  {sizeof(qmiLocGetXtraTSessionControlIndMsgT_v02), qmiLocGetXtraTSessionControlIndMsgT_data_v02},
+  {sizeof(qmiLocInjectWifiPositionReqMsgT_v02), qmiLocInjectWifiPositionReqMsgT_data_v02},
+  {sizeof(qmiLocInjectWifiPositionIndMsgT_v02), qmiLocInjectWifiPositionIndMsgT_data_v02},
+  {sizeof(qmiLocNotifyWifiStatusReqMsgT_v02), qmiLocNotifyWifiStatusReqMsgT_data_v02},
+  {sizeof(qmiLocNotifyWifiStatusIndMsgT_v02), qmiLocNotifyWifiStatusIndMsgT_data_v02},
+  {sizeof(qmiLocGetRegisteredEventsReqMsgT_v02), 0},
+  {sizeof(qmiLocGetRegisteredEventsIndMsgT_v02), qmiLocGetRegisteredEventsIndMsgT_data_v02},
+  {sizeof(qmiLocSetOperationModeReqMsgT_v02), qmiLocSetOperationModeReqMsgT_data_v02},
+  {sizeof(qmiLocSetOperationModeIndMsgT_v02), qmiLocSetOperationModeIndMsgT_data_v02},
+  {sizeof(qmiLocGetOperationModeReqMsgT_v02), 0},
+  {sizeof(qmiLocGetOperationModeIndMsgT_v02), qmiLocGetOperationModeIndMsgT_data_v02},
+  {sizeof(qmiLocSetSpiStatusReqMsgT_v02), qmiLocSetSpiStatusReqMsgT_data_v02},
+  {sizeof(qmiLocSetSpiStatusIndMsgT_v02), qmiLocSetSpiStatusIndMsgT_data_v02},
+  {sizeof(qmiLocInjectSensorDataReqMsgT_v02), qmiLocInjectSensorDataReqMsgT_data_v02},
+  {sizeof(qmiLocInjectSensorDataIndMsgT_v02), qmiLocInjectSensorDataIndMsgT_data_v02},
+  {sizeof(qmiLocInjectTimeSyncDataReqMsgT_v02), qmiLocInjectTimeSyncDataReqMsgT_data_v02},
+  {sizeof(qmiLocInjectTimeSyncDataIndMsgT_v02), qmiLocInjectTimeSyncDataIndMsgT_data_v02},
+  {sizeof(qmiLocGetCradleMountConfigReqMsgT_v02), 0},
+  {sizeof(qmiLocGetCradleMountConfigIndMsgT_v02), qmiLocGetCradleMountConfigIndMsgT_data_v02},
+  {sizeof(qmiLocSetCradleMountConfigReqMsgT_v02), qmiLocSetCradleMountConfigReqMsgT_data_v02},
+  {sizeof(qmiLocSetCradleMountConfigIndMsgT_v02), qmiLocSetCradleMountConfigIndMsgT_data_v02},
+  {sizeof(qmiLocGetExternalPowerConfigReqMsgT_v02), 0},
+  {sizeof(qmiLocGetExternalPowerConfigIndMsgT_v02), qmiLocGetExternalPowerConfigIndMsgT_data_v02},
+  {sizeof(qmiLocSetExternalPowerConfigReqMsgT_v02), qmiLocSetExternalPowerConfigReqMsgT_data_v02},
+  {sizeof(qmiLocSetExternalPowerConfigIndMsgT_v02), qmiLocSetExternalPowerConfigIndMsgT_data_v02},
+  {sizeof(qmiLocInformLocationServerConnStatusReqMsgT_v02), qmiLocInformLocationServerConnStatusReqMsgT_data_v02},
+  {sizeof(qmiLocInformLocationServerConnStatusIndMsgT_v02), qmiLocInformLocationServerConnStatusIndMsgT_data_v02},
+  {sizeof(qmiLocSetProtocolConfigParametersReqMsgT_v02), qmiLocSetProtocolConfigParametersReqMsgT_data_v02},
+  {sizeof(qmiLocSetProtocolConfigParametersIndMsgT_v02), qmiLocSetProtocolConfigParametersIndMsgT_data_v02},
+  {sizeof(qmiLocGetProtocolConfigParametersReqMsgT_v02), qmiLocGetProtocolConfigParametersReqMsgT_data_v02},
+  {sizeof(qmiLocGetProtocolConfigParametersIndMsgT_v02), qmiLocGetProtocolConfigParametersIndMsgT_data_v02},
+  {sizeof(qmiLocSetSensorControlConfigReqMsgT_v02), qmiLocSetSensorControlConfigReqMsgT_data_v02},
+  {sizeof(qmiLocSetSensorControlConfigIndMsgT_v02), qmiLocSetSensorControlConfigIndMsgT_data_v02},
+  {sizeof(qmiLocGetSensorControlConfigReqMsgT_v02), 0},
+  {sizeof(qmiLocGetSensorControlConfigIndMsgT_v02), qmiLocGetSensorControlConfigIndMsgT_data_v02},
+  {sizeof(qmiLocSetSensorPropertiesReqMsgT_v02), qmiLocSetSensorPropertiesReqMsgT_data_v02},
+  {sizeof(qmiLocSetSensorPropertiesIndMsgT_v02), qmiLocSetSensorPropertiesIndMsgT_data_v02},
+  {sizeof(qmiLocGetSensorPropertiesReqMsgT_v02), qmiLocGetSensorPropertiesReqMsgT_data_v02},
+  {sizeof(qmiLocGetSensorPropertiesIndMsgT_v02), qmiLocGetSensorPropertiesIndMsgT_data_v02},
+  {sizeof(qmiLocSetSensorPerformanceControlConfigReqMsgT_v02), qmiLocSetSensorPerformanceControlConfigReqMsgT_data_v02},
+  {sizeof(qmiLocSetSensorPerformanceControlConfigIndMsgT_v02), qmiLocSetSensorPerformanceControlConfigIndMsgT_data_v02},
+  {sizeof(qmiLocGetSensorPerformanceControlConfigReqMsgT_v02), 0},
+  {sizeof(qmiLocGetSensorPerformanceControlConfigIndMsgT_v02), qmiLocGetSensorPerformanceControlConfigIndMsgT_data_v02},
+  {sizeof(qmiLocInjectSuplCertificateReqMsgT_v02), qmiLocInjectSuplCertificateReqMsgT_data_v02},
+  {sizeof(qmiLocInjectSuplCertificateIndMsgT_v02), qmiLocInjectSuplCertificateIndMsgT_data_v02},
+  {sizeof(qmiLocDeleteSuplCertificateReqMsgT_v02), qmiLocDeleteSuplCertificateReqMsgT_data_v02},
+  {sizeof(qmiLocDeleteSuplCertificateIndMsgT_v02), qmiLocDeleteSuplCertificateIndMsgT_data_v02},
+  {sizeof(qmiLocSetPositionEngineConfigParametersReqMsgT_v02), qmiLocSetPositionEngineConfigParametersReqMsgT_data_v02},
+  {sizeof(qmiLocSetPositionEngineConfigParametersIndMsgT_v02), qmiLocSetPositionEngineConfigParametersIndMsgT_data_v02},
+  {sizeof(qmiLocGetPositionEngineConfigParametersReqMsgT_v02), qmiLocGetPositionEngineConfigParametersReqMsgT_data_v02},
+  {sizeof(qmiLocGetPositionEngineConfigParametersIndMsgT_v02), qmiLocGetPositionEngineConfigParametersIndMsgT_data_v02},
+  {sizeof(qmiLocAddCircularGeofenceReqMsgT_v02), qmiLocAddCircularGeofenceReqMsgT_data_v02},
+  {sizeof(qmiLocAddCircularGeofenceIndMsgT_v02), qmiLocAddCircularGeofenceIndMsgT_data_v02},
+  {sizeof(qmiLocDeleteGeofenceReqMsgT_v02), qmiLocDeleteGeofenceReqMsgT_data_v02},
+  {sizeof(qmiLocDeleteGeofenceIndMsgT_v02), qmiLocDeleteGeofenceIndMsgT_data_v02},
+  {sizeof(qmiLocQueryGeofenceReqMsgT_v02), qmiLocQueryGeofenceReqMsgT_data_v02},
+  {sizeof(qmiLocQueryGeofenceIndMsgT_v02), qmiLocQueryGeofenceIndMsgT_data_v02},
+  {sizeof(qmiLocSetGeofenceEngineConfigReqMsgT_v02), qmiLocSetGeofenceEngineConfigReqMsgT_data_v02},
+  {sizeof(qmiLocSetGeofenceEngineConfigIndMsgT_v02), qmiLocSetGeofenceEngineConfigIndMsgT_data_v02},
+  {sizeof(qmiLocGetGeofenceEngineConfigReqMsgT_v02), qmiLocGetGeofenceEngineConfigReqMsgT_data_v02},
+  {sizeof(qmiLocGetGeofenceEngineConfigIndMsgT_v02), qmiLocGetGeofenceEngineConfigIndMsgT_data_v02},
+  {sizeof(qmiLocEditGeofenceReqMsgT_v02), qmiLocEditGeofenceReqMsgT_data_v02},
+  {sizeof(qmiLocEditGeofenceIndMsgT_v02), qmiLocEditGeofenceIndMsgT_data_v02},
+  {sizeof(qmiLocEventGetTimeZoneReqIndMsgT_v02), qmiLocEventGetTimeZoneReqIndMsgT_data_v02},
+  {sizeof(qmiLocInjectTimeZoneInfoReqMsgT_v02), qmiLocInjectTimeZoneInfoReqMsgT_data_v02},
+  {sizeof(qmiLocInjectTimeZoneInfoIndMsgT_v02), qmiLocInjectTimeZoneInfoIndMsgT_data_v02},
+  {sizeof(qmiLocGetBestAvailablePositionReqMsgT_v02), qmiLocGetBestAvailablePositionReqMsgT_data_v02},
+  {sizeof(qmiLocGetBestAvailablePositionIndMsgT_v02), qmiLocGetBestAvailablePositionIndMsgT_data_v02},
+  {sizeof(qmiLocInjectMotionDataReqMsgT_v02), qmiLocInjectMotionDataReqMsgT_data_v02},
+  {sizeof(qmiLocInjectMotionDataIndMsgT_v02), qmiLocInjectMotionDataIndMsgT_data_v02},
+  {sizeof(qmiLocGetNiGeofenceIdListReqMsgT_v02), qmiLocGetNiGeofenceIdListReqMsgT_data_v02},
+  {sizeof(qmiLocGetNiGeofenceIdListIndMsgT_v02), qmiLocGetNiGeofenceIdListIndMsgT_data_v02},
+  {sizeof(qmiLocInjectGSMCellInfoReqMsgT_v02), qmiLocInjectGSMCellInfoReqMsgT_data_v02},
+  {sizeof(qmiLocInjectGSMCellInfoIndMsgT_v02), qmiLocInjectGSMCellInfoIndMsgT_data_v02},
+  {sizeof(qmiLocInjectWCDMACellInfoReqMsgT_v02), qmiLocInjectWCDMACellInfoReqMsgT_data_v02},
+  {sizeof(qmiLocInjectWCDMACellInfoIndMsgT_v02), qmiLocInjectWCDMACellInfoIndMsgT_data_v02},
+  {sizeof(qmiLocInjectTDSCDMACellInfoReqMsgT_v02), qmiLocInjectTDSCDMACellInfoReqMsgT_data_v02},
+  {sizeof(qmiLocInjectTDSCDMACellInfoIndMsgT_v02), qmiLocInjectTDSCDMACellInfoIndMsgT_data_v02},
+  {sizeof(qmiLocInjectSubscriberIDReqMsgT_v02), qmiLocInjectSubscriberIDReqMsgT_data_v02},
+  {sizeof(qmiLocInjectSubscriberIDIndMsgT_v02), qmiLocInjectSubscriberIDIndMsgT_data_v02},
+  {sizeof(qmiLocInjectNetworkInitiatedMessageReqMsgT_v02), qmiLocInjectNetworkInitiatedMessageReqMsgT_data_v02},
+  {sizeof(qmiLocInjectNetworkInitiatedMessageIndMsgT_v02), qmiLocInjectNetworkInitiatedMessageIndMsgT_data_v02},
+  {sizeof(qmiLocWWANOutOfServiceNotificationReqMsgT_v02), 0},
+  {sizeof(qmiLocWWANOutOfServiceNotificationIndMsgT_v02), qmiLocWWANOutOfServiceNotificationIndMsgT_data_v02},
+  {sizeof(qmiLocPedometerReportReqMsgT_v02), qmiLocPedometerReportReqMsgT_data_v02},
+  {sizeof(qmiLocPedometerReportIndMsgT_v02), qmiLocPedometerReportIndMsgT_data_v02},
+  {sizeof(qmiLocGetBatchSizeReqMsgT_v02), qmiLocGetBatchSizeReqMsgT_data_v02},
+  {sizeof(qmiLocGetBatchSizeIndMsgT_v02), qmiLocGetBatchSizeIndMsgT_data_v02},
+  {sizeof(qmiLocStartBatchingReqMsgT_v02), qmiLocStartBatchingReqMsgT_data_v02},
+  {sizeof(qmiLocStartBatchingIndMsgT_v02), qmiLocStartBatchingIndMsgT_data_v02},
+  {sizeof(qmiLocEventBatchFullIndMsgT_v02), qmiLocEventBatchFullIndMsgT_data_v02},
+  {sizeof(qmiLocEventLiveBatchedPositionReportIndMsgT_v02), qmiLocEventLiveBatchedPositionReportIndMsgT_data_v02},
+  {sizeof(qmiLocReadFromBatchReqMsgT_v02), qmiLocReadFromBatchReqMsgT_data_v02},
+  {sizeof(qmiLocReadFromBatchIndMsgT_v02), qmiLocReadFromBatchIndMsgT_data_v02},
+  {sizeof(qmiLocStopBatchingReqMsgT_v02), qmiLocStopBatchingReqMsgT_data_v02},
+  {sizeof(qmiLocStopBatchingIndMsgT_v02), qmiLocStopBatchingIndMsgT_data_v02},
+  {sizeof(qmiLocReleaseBatchReqMsgT_v02), qmiLocReleaseBatchReqMsgT_data_v02},
+  {sizeof(qmiLocReleaseBatchIndMsgT_v02), qmiLocReleaseBatchIndMsgT_data_v02},
+  {sizeof(qmiLocEventInjectWifiApDataReqIndMsgT_v02), qmiLocEventInjectWifiApDataReqIndMsgT_data_v02},
+  {sizeof(qmiLocInjectWifiApDataReqMsgT_v02), qmiLocInjectWifiApDataReqMsgT_data_v02},
+  {sizeof(qmiLocInjectWifiApDataIndMsgT_v02), qmiLocInjectWifiApDataIndMsgT_data_v02},
+  {sizeof(qmiLocNotifyWifiAttachmentStatusReqMsgT_v02), qmiLocNotifyWifiAttachmentStatusReqMsgT_data_v02},
+  {sizeof(qmiLocNotifyWifiAttachmentStatusIndMsgT_v02), qmiLocNotifyWifiAttachmentStatusIndMsgT_data_v02},
+  {sizeof(qmiLocNotifyWifiEnabledStatusReqMsgT_v02), qmiLocNotifyWifiEnabledStatusReqMsgT_data_v02},
+  {sizeof(qmiLocNotifyWifiEnabledStatusIndMsgT_v02), qmiLocNotifyWifiEnabledStatusIndMsgT_data_v02},
+  {sizeof(qmiLocEventVehicleDataReadyIndMsgT_v02), qmiLocEventVehicleDataReadyIndMsgT_data_v02},
+  {sizeof(qmiLocInjectVehicleSensorDataReqMsgT_v02), qmiLocInjectVehicleSensorDataReqMsgT_data_v02},
+  {sizeof(qmiLocInjectVehicleSensorDataIndMsgT_v02), qmiLocInjectVehicleSensorDataIndMsgT_data_v02},
+  {sizeof(qmiLocGetAvailWwanPositionReqMsgT_v02), qmiLocGetAvailWwanPositionReqMsgT_data_v02},
+  {sizeof(qmiLocGetAvailWwanPositionIndMsgT_v02), qmiLocGetAvailWwanPositionIndMsgT_data_v02},
+  {sizeof(qmiLocSetPremiumServicesCfgReqMsgT_v02), qmiLocSetPremiumServicesCfgReqMsgT_data_v02},
+  {sizeof(qmiLocSetPremiumServicesCfgIndMsgT_v02), qmiLocSetPremiumServicesCfgIndMsgT_data_v02},
+  {sizeof(qmiLocSetXtraVersionCheckReqMsgT_v02), qmiLocSetXtraVersionCheckReqMsgT_data_v02},
+  {sizeof(qmiLocSetXtraVersionCheckIndMsgT_v02), qmiLocSetXtraVersionCheckIndMsgT_data_v02},
+  {sizeof(qmiLocSetGNSSConstRepConfigReqMsgT_v02), qmiLocSetGNSSConstRepConfigReqMsgT_data_v02},
+  {sizeof(qmiLocSetGNSSConstRepConfigIndMsgT_v02), qmiLocSetGNSSConstRepConfigIndMsgT_data_v02},
+  {sizeof(qmiLocEventGnssSvMeasInfoIndMsgT_v02), qmiLocEventGnssSvMeasInfoIndMsgT_data_v02},
+  {sizeof(qmiLocEventGnssSvPolyIndMsgT_v02), qmiLocEventGnssSvPolyIndMsgT_data_v02},
+  {sizeof(qmiLocAddGeofenceContextReqMsgT_v02), qmiLocAddGeofenceContextReqMsgT_data_v02},
+  {sizeof(qmiLocAddGeofenceContextIndMsgT_v02), qmiLocAddGeofenceContextIndMsgT_data_v02},
+  {sizeof(qmiLocSetGeofenceEngineContextReqMsgT_v02), qmiLocSetGeofenceEngineContextReqMsgT_data_v02},
+  {sizeof(qmiLocSetGeofenceEngineContextIndMsgT_v02), qmiLocSetGeofenceEngineContextIndMsgT_data_v02},
+  {sizeof(qmiLocDeleteGeofenceContextReqMsgT_v02), qmiLocDeleteGeofenceContextReqMsgT_data_v02},
+  {sizeof(qmiLocDeleteGeofenceContextIndMsgT_v02), qmiLocDeleteGeofenceContextIndMsgT_data_v02},
+  {sizeof(qmiLocInjectGtpClientDownloadedDataReqMsgT_v02), qmiLocInjectGtpClientDownloadedDataReqMsgT_data_v02},
+  {sizeof(qmiLocInjectGtpClientDownloadedDataIndMsgT_v02), qmiLocInjectGtpClientDownloadedDataIndMsgT_data_v02},
+  {sizeof(qmiLocGdtUploadBeginStatusReqMsgT_v02), qmiLocGdtUploadBeginStatusReqMsgT_data_v02},
+  {sizeof(qmiLocGdtUploadBeginStatusIndMsgT_v02), qmiLocGdtUploadBeginStatusIndMsgT_data_v02},
+  {sizeof(qmiLocGdtUploadEndReqMsgT_v02), qmiLocGdtUploadEndReqMsgT_data_v02},
+  {sizeof(qmiLocGdtUploadEndIndMsgT_v02), qmiLocGdtUploadEndIndMsgT_data_v02},
+  {sizeof(qmiLocGtpApStatusReqMsgT_v02), qmiLocGtpApStatusReqMsgT_data_v02},
+  {sizeof(qmiLocGtpApStatusIndMsgT_v02), qmiLocGtpApStatusIndMsgT_data_v02},
+  {sizeof(qmiLocGdtDownloadBeginStatusReqMsgT_v02), qmiLocGdtDownloadBeginStatusReqMsgT_data_v02},
+  {sizeof(qmiLocGdtDownloadBeginStatusIndMsgT_v02), qmiLocGdtDownloadBeginStatusIndMsgT_data_v02},
+  {sizeof(qmiLocGdtDownloadReadyStatusReqMsgT_v02), qmiLocGdtDownloadReadyStatusReqMsgT_data_v02},
+  {sizeof(qmiLocGdtDownloadReadyStatusIndMsgT_v02), qmiLocGdtDownloadReadyStatusIndMsgT_data_v02},
+  {sizeof(qmiLocGdtReceiveDoneStatusReqMsgT_v02), qmiLocGdtReceiveDoneStatusReqMsgT_data_v02},
+  {sizeof(qmiLocGdtReceiveDoneStatusIndMsgT_v02), qmiLocGdtReceiveDoneStatusIndMsgT_data_v02},
+  {sizeof(qmiLocGdtDownloadEndStatusReqMsgT_v02), qmiLocGdtDownloadEndStatusReqMsgT_data_v02},
+  {sizeof(qmiLocGdtDownloadEndStatusIndMsgT_v02), qmiLocGdtDownloadEndStatusIndMsgT_data_v02},
+  {sizeof(qmiLocStartDbtReqMsgT_v02), qmiLocStartDbtReqMsgT_data_v02},
+  {sizeof(qmiLocStartDbtIndMsgT_v02), qmiLocStartDbtIndMsgT_data_v02},
+  {sizeof(qmiLocStopDbtReqMsgT_v02), qmiLocStopDbtReqMsgT_data_v02},
+  {sizeof(qmiLocStopDbtIndMsgT_v02), qmiLocStopDbtIndMsgT_data_v02},
+  {sizeof(qmiLocEventDbtPositionReportIndMsgT_v02), qmiLocEventDbtPositionReportIndMsgT_data_v02},
+  {sizeof(qmiLocEventDbtSessionStatusIndMsgT_v02), qmiLocEventDbtSessionStatusIndMsgT_data_v02},
+  {sizeof(qmiLocSecureGetAvailablePositionReqMsgT_v02), qmiLocSecureGetAvailablePositionReqMsgT_data_v02},
+  {sizeof(qmiLocSecureGetAvailablePositionIndMsgT_v02), qmiLocSecureGetAvailablePositionIndMsgT_data_v02},
+  {sizeof(qmiLocInjectApCacheDataReqMsgT_v02), qmiLocInjectApCacheDataReqMsgT_data_v02},
+  {sizeof(qmiLocInjectApCacheDataIndMsgT_v02), qmiLocInjectApCacheDataIndMsgT_data_v02},
+  {sizeof(qmiLocInjectApDoNotCacheDataReqMsgT_v02), qmiLocInjectApDoNotCacheDataReqMsgT_data_v02},
+  {sizeof(qmiLocInjectApDoNotCacheDataIndMsgT_v02), qmiLocInjectApDoNotCacheDataIndMsgT_data_v02},
+  {sizeof(qmiLocEventBatchingStatusIndMsgT_v02), qmiLocEventBatchingStatusIndMsgT_data_v02},
+  {sizeof(qmiLocQueryAonConfigReqMsgT_v02), qmiLocQueryAonConfigReqMsgT_data_v02},
+  {sizeof(qmiLocQueryAonConfigIndMsgT_v02), qmiLocQueryAonConfigIndMsgT_data_v02},
+  {sizeof(qmiLocDeleteGNSSServiceDataReqMsgT_v02), qmiLocDeleteGNSSServiceDataReqMsgT_data_v02},
+  {sizeof(qmiLocDeleteGNSSServiceDataIndMsgT_v02), qmiLocDeleteGNSSServiceDataIndMsgT_data_v02},
+  {sizeof(qmiLocInjectXtraDataReqMsgT_v02), qmiLocInjectXtraDataReqMsgT_data_v02},
+  {sizeof(qmiLocInjectXtraDataIndMsgT_v02), qmiLocInjectXtraDataIndMsgT_data_v02},
+  {sizeof(qmiLocInjectXtraPcidReqMsgT_v02), qmiLocInjectXtraPcidReqMsgT_data_v02},
+  {sizeof(qmiLocInjectXtraPcidIndMsgT_v02), qmiLocInjectXtraPcidIndMsgT_data_v02},
+  {sizeof(qmiLocGetSupportedFeatureReqMsgT_v02), 0},
+  {sizeof(qmiLocGetSupportedFeatureIndMsgT_v02), qmiLocGetSupportedFeatureIndMsgT_data_v02}
+};
+
+/* Range Table */
+/* No Ranges Defined in IDL */
+
+/* Predefine the Type Table Object */
+static const qmi_idl_type_table_object loc_qmi_idl_type_table_object_v02;
+
+/*Referenced Tables Array*/
+static const qmi_idl_type_table_object *loc_qmi_idl_type_table_object_referenced_tables_v02[] =
+{&loc_qmi_idl_type_table_object_v02, &common_qmi_idl_type_table_object_v01};
+
+/*Type Table Object*/
+static const qmi_idl_type_table_object loc_qmi_idl_type_table_object_v02 = {
+  sizeof(loc_type_table_v02)/sizeof(qmi_idl_type_table_entry ),
+  sizeof(loc_message_table_v02)/sizeof(qmi_idl_message_table_entry),
+  1,
+  loc_type_table_v02,
+  loc_message_table_v02,
+  loc_qmi_idl_type_table_object_referenced_tables_v02,
+  NULL
+};
+
+/*Arrays of service_message_table_entries for commands, responses and indications*/
+static const qmi_idl_service_message_table_entry loc_service_command_messages_v02[] = {
+  {QMI_LOC_GET_SUPPORTED_MSGS_REQ_V02, QMI_IDL_TYPE16(1, 0), 0},
+  {QMI_LOC_GET_SUPPORTED_FIELDS_REQ_V02, QMI_IDL_TYPE16(1, 2), 5},
+  {QMI_LOC_INFORM_CLIENT_REVISION_REQ_V02, QMI_IDL_TYPE16(0, 1), 7},
+  {QMI_LOC_REG_EVENTS_REQ_V02, QMI_IDL_TYPE16(0, 2), 11},
+  {QMI_LOC_START_REQ_V02, QMI_IDL_TYPE16(0, 3), 128},
+  {QMI_LOC_STOP_REQ_V02, QMI_IDL_TYPE16(0, 4), 4},
+  {QMI_LOC_GET_SERVICE_REVISION_REQ_V02, QMI_IDL_TYPE16(0, 32), 0},
+  {QMI_LOC_GET_FIX_CRITERIA_REQ_V02, QMI_IDL_TYPE16(0, 34), 0},
+  {QMI_LOC_NI_USER_RESPONSE_REQ_V02, QMI_IDL_TYPE16(0, 36), 1345},
+  {QMI_LOC_INJECT_PREDICTED_ORBITS_DATA_REQ_V02, QMI_IDL_TYPE16(0, 38), 1053},
+  {QMI_LOC_GET_PREDICTED_ORBITS_DATA_SOURCE_REQ_V02, QMI_IDL_TYPE16(0, 40), 0},
+  {QMI_LOC_GET_PREDICTED_ORBITS_DATA_VALIDITY_REQ_V02, QMI_IDL_TYPE16(0, 42), 0},
+  {QMI_LOC_INJECT_UTC_TIME_REQ_V02, QMI_IDL_TYPE16(0, 44), 18},
+  {QMI_LOC_INJECT_POSITION_REQ_V02, QMI_IDL_TYPE16(0, 46), 127},
+  {QMI_LOC_SET_ENGINE_LOCK_REQ_V02, QMI_IDL_TYPE16(0, 48), 7},
+  {QMI_LOC_GET_ENGINE_LOCK_REQ_V02, QMI_IDL_TYPE16(0, 50), 0},
+  {QMI_LOC_SET_SBAS_CONFIG_REQ_V02, QMI_IDL_TYPE16(0, 52), 4},
+  {QMI_LOC_GET_SBAS_CONFIG_REQ_V02, QMI_IDL_TYPE16(0, 54), 0},
+  {QMI_LOC_SET_NMEA_TYPES_REQ_V02, QMI_IDL_TYPE16(0, 56), 7},
+  {QMI_LOC_GET_NMEA_TYPES_REQ_V02, QMI_IDL_TYPE16(0, 58), 0},
+  {QMI_LOC_SET_LOW_POWER_MODE_REQ_V02, QMI_IDL_TYPE16(0, 60), 4},
+  {QMI_LOC_GET_LOW_POWER_MODE_REQ_V02, QMI_IDL_TYPE16(0, 62), 0},
+  {QMI_LOC_SET_SERVER_REQ_V02, QMI_IDL_TYPE16(0, 64), 297},
+  {QMI_LOC_GET_SERVER_REQ_V02, QMI_IDL_TYPE16(0, 66), 11},
+  {QMI_LOC_DELETE_ASSIST_DATA_REQ_V02, QMI_IDL_TYPE16(0, 68), 1156},
+  {QMI_LOC_SET_XTRA_T_SESSION_CONTROL_REQ_V02, QMI_IDL_TYPE16(0, 70), 4},
+  {QMI_LOC_GET_XTRA_T_SESSION_CONTROL_REQ_V02, QMI_IDL_TYPE16(0, 72), 0},
+  {QMI_LOC_INJECT_WIFI_POSITION_REQ_V02, QMI_IDL_TYPE16(0, 74), 2353},
+  {QMI_LOC_NOTIFY_WIFI_STATUS_REQ_V02, QMI_IDL_TYPE16(0, 76), 7},
+  {QMI_LOC_GET_REGISTERED_EVENTS_REQ_V02, QMI_IDL_TYPE16(0, 78), 0},
+  {QMI_LOC_SET_OPERATION_MODE_REQ_V02, QMI_IDL_TYPE16(0, 80), 14},
+  {QMI_LOC_GET_OPERATION_MODE_REQ_V02, QMI_IDL_TYPE16(0, 82), 0},
+  {QMI_LOC_SET_SPI_STATUS_REQ_V02, QMI_IDL_TYPE16(0, 84), 8},
+  {QMI_LOC_INJECT_SENSOR_DATA_REQ_V02, QMI_IDL_TYPE16(0, 86), 2779},
+  {QMI_LOC_INJECT_TIME_SYNC_DATA_REQ_V02, QMI_IDL_TYPE16(0, 88), 21},
+  {QMI_LOC_SET_CRADLE_MOUNT_CONFIG_REQ_V02, QMI_IDL_TYPE16(0, 92), 11},
+  {QMI_LOC_GET_CRADLE_MOUNT_CONFIG_REQ_V02, QMI_IDL_TYPE16(0, 90), 0},
+  {QMI_LOC_SET_EXTERNAL_POWER_CONFIG_REQ_V02, QMI_IDL_TYPE16(0, 96), 7},
+  {QMI_LOC_GET_EXTERNAL_POWER_CONFIG_REQ_V02, QMI_IDL_TYPE16(0, 94), 0},
+  {QMI_LOC_INFORM_LOCATION_SERVER_CONN_STATUS_REQ_V02, QMI_IDL_TYPE16(0, 98), 129},
+  {QMI_LOC_SET_PROTOCOL_CONFIG_PARAMETERS_REQ_V02, QMI_IDL_TYPE16(0, 100), 79},
+  {QMI_LOC_GET_PROTOCOL_CONFIG_PARAMETERS_REQ_V02, QMI_IDL_TYPE16(0, 102), 11},
+  {QMI_LOC_SET_SENSOR_CONTROL_CONFIG_REQ_V02, QMI_IDL_TYPE16(0, 104), 14},
+  {QMI_LOC_GET_SENSOR_CONTROL_CONFIG_REQ_V02, QMI_IDL_TYPE16(0, 106), 0},
+  {QMI_LOC_SET_SENSOR_PROPERTIES_REQ_V02, QMI_IDL_TYPE16(0, 108), 88},
+  {QMI_LOC_GET_SENSOR_PROPERTIES_REQ_V02, QMI_IDL_TYPE16(0, 110), 7},
+  {QMI_LOC_SET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_REQ_V02, QMI_IDL_TYPE16(0, 112), 42},
+  {QMI_LOC_GET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_REQ_V02, QMI_IDL_TYPE16(0, 114), 0},
+  {QMI_LOC_INJECT_SUPL_CERTIFICATE_REQ_V02, QMI_IDL_TYPE16(0, 116), 2009},
+  {QMI_LOC_DELETE_SUPL_CERTIFICATE_REQ_V02, QMI_IDL_TYPE16(0, 118), 4},
+  {QMI_LOC_SET_POSITION_ENGINE_CONFIG_PARAMETERS_REQ_V02, QMI_IDL_TYPE16(0, 120), 16},
+  {QMI_LOC_GET_POSITION_ENGINE_CONFIG_PARAMETERS_REQ_V02, QMI_IDL_TYPE16(0, 122), 7},
+  {QMI_LOC_ADD_CIRCULAR_GEOFENCE_REQ_V02, QMI_IDL_TYPE16(0, 124), 70},
+  {QMI_LOC_DELETE_GEOFENCE_REQ_V02, QMI_IDL_TYPE16(0, 126), 14},
+  {QMI_LOC_QUERY_GEOFENCE_REQ_V02, QMI_IDL_TYPE16(0, 128), 14},
+  {QMI_LOC_EDIT_GEOFENCE_REQ_V02, QMI_IDL_TYPE16(0, 134), 32},
+  {QMI_LOC_GET_BEST_AVAILABLE_POSITION_REQ_V02, QMI_IDL_TYPE16(0, 139), 7},
+  {QMI_LOC_INJECT_MOTION_DATA_REQ_V02, QMI_IDL_TYPE16(0, 141), 19},
+  {QMI_LOC_GET_NI_GEOFENCE_ID_LIST_REQ_V02, QMI_IDL_TYPE16(0, 143), 7},
+  {QMI_LOC_INJECT_GSM_CELL_INFO_REQ_V02, QMI_IDL_TYPE16(0, 145), 30},
+  {QMI_LOC_INJECT_NETWORK_INITIATED_MESSAGE_REQ_V02, QMI_IDL_TYPE16(0, 153), 1036},
+  {QMI_LOC_WWAN_OUT_OF_SERVICE_NOTIFICATION_REQ_V02, QMI_IDL_TYPE16(0, 155), 0},
+  {QMI_LOC_PEDOMETER_REPORT_REQ_V02, QMI_IDL_TYPE16(0, 157), 46},
+  {QMI_LOC_INJECT_WCDMA_CELL_INFO_REQ_V02, QMI_IDL_TYPE16(0, 147), 36},
+  {QMI_LOC_INJECT_TDSCDMA_CELL_INFO_REQ_V02, QMI_IDL_TYPE16(0, 149), 33},
+  {QMI_LOC_INJECT_SUBSCRIBER_ID_REQ_V02, QMI_IDL_TYPE16(0, 151), 22},
+  {QMI_LOC_SET_GEOFENCE_ENGINE_CONFIG_REQ_V02, QMI_IDL_TYPE16(0, 130), 224},
+  {QMI_LOC_GET_GEOFENCE_ENGINE_CONFIG_REQ_V02, QMI_IDL_TYPE16(0, 132), 7},
+  {QMI_LOC_GET_BATCH_SIZE_REQ_V02, QMI_IDL_TYPE16(0, 159), 14},
+  {QMI_LOC_START_BATCHING_REQ_V02, QMI_IDL_TYPE16(0, 161), 39},
+  {QMI_LOC_READ_FROM_BATCH_REQ_V02, QMI_IDL_TYPE16(0, 165), 14},
+  {QMI_LOC_STOP_BATCHING_REQ_V02, QMI_IDL_TYPE16(0, 167), 14},
+  {QMI_LOC_RELEASE_BATCH_REQ_V02, QMI_IDL_TYPE16(0, 169), 7},
+  {QMI_LOC_INJECT_WIFI_AP_DATA_REQ_V02, QMI_IDL_TYPE16(0, 172), 5191},
+  {QMI_LOC_NOTIFY_WIFI_ATTACHMENT_STATUS_REQ_V02, QMI_IDL_TYPE16(0, 174), 51},
+  {QMI_LOC_NOTIFY_WIFI_ENABLED_STATUS_REQ_V02, QMI_IDL_TYPE16(0, 176), 7},
+  {QMI_LOC_INJECT_VEHICLE_SENSOR_DATA_REQ_V02, QMI_IDL_TYPE16(0, 179), 3360},
+  {QMI_LOC_GET_AVAILABLE_WWAN_POSITION_REQ_V02, QMI_IDL_TYPE16(0, 181), 7},
+  {QMI_LOC_SET_PREMIUM_SERVICES_CONFIG_REQ_V02, QMI_IDL_TYPE16(0, 183), 14},
+  {QMI_LOC_SET_XTRA_VERSION_CHECK_REQ_V02, QMI_IDL_TYPE16(0, 185), 7},
+  {QMI_LOC_SET_GNSS_CONSTELL_REPORT_CONFIG_V02, QMI_IDL_TYPE16(0, 187), 22},
+  {QMI_LOC_ADD_GEOFENCE_CONTEXT_REQ_V02, QMI_IDL_TYPE16(0, 191), 2517},
+  {QMI_LOC_SET_GEOFENCE_ENGINE_CONTEXT_REQ_V02, QMI_IDL_TYPE16(0, 193), 25},
+  {QMI_LOC_DELETE_GEOFENCE_CONTEXT_REQ_V02, QMI_IDL_TYPE16(0, 195), 21},
+  {QMI_LOC_INJECT_GTP_CLIENT_DOWNLOADED_DATA_REQ_V02, QMI_IDL_TYPE16(0, 197), 517},
+  {QMI_LOC_GDT_UPLOAD_BEGIN_STATUS_REQ_V02, QMI_IDL_TYPE16(0, 199), 21},
+  {QMI_LOC_GDT_UPLOAD_END_REQ_V02, QMI_IDL_TYPE16(0, 201), 21},
+  {QMI_LOC_START_DBT_REQ_V02, QMI_IDL_TYPE16(0, 213), 36},
+  {QMI_LOC_STOP_DBT_REQ_V02, QMI_IDL_TYPE16(0, 215), 4},
+  {QMI_LOC_SECURE_GET_AVAILABLE_POSITION_REQ_V02, QMI_IDL_TYPE16(0, 219), 268},
+  {QMI_LOC_INJECT_TIME_ZONE_INFO_REQ_V02, QMI_IDL_TYPE16(0, 137), 30},
+  {QMI_LOC_INJECT_APCACHE_DATA_REQ_V02, QMI_IDL_TYPE16(0, 221), 2180},
+  {QMI_LOC_INJECT_APDONOTCACHE_DATA_REQ_V02, QMI_IDL_TYPE16(0, 223), 656},
+  {QMI_LOC_QUERY_AON_CONFIG_REQ_V02, QMI_IDL_TYPE16(0, 226), 7},
+  {QMI_LOC_GTP_AP_STATUS_REQ_V02, QMI_IDL_TYPE16(0, 203), 540},
+  {QMI_LOC_GDT_DOWNLOAD_BEGIN_STATUS_REQ_V02, QMI_IDL_TYPE16(0, 205), 294},
+  {QMI_LOC_GDT_DOWNLOAD_READY_STATUS_REQ_V02, QMI_IDL_TYPE16(0, 207), 280},
+  {QMI_LOC_GDT_RECEIVE_DONE_STATUS_REQ_V02, QMI_IDL_TYPE16(0, 209), 21},
+  {QMI_LOC_GDT_DOWNLOAD_END_STATUS_REQ_V02, QMI_IDL_TYPE16(0, 211), 21},
+  {QMI_LOC_DELETE_GNSS_SERVICE_DATA_REQ_V02, QMI_IDL_TYPE16(0, 228), 36},
+  {QMI_LOC_INJECT_XTRA_DATA_REQ_V02, QMI_IDL_TYPE16(0, 230), 1053},
+  {QMI_LOC_INJECT_XTRA_PCID_REQ_V02, QMI_IDL_TYPE16(0, 232), 11},
+  {QMI_LOC_GET_SUPPORTED_FEATURE_REQ_V02, QMI_IDL_TYPE16(0, 234), 0}
+};
+
+static const qmi_idl_service_message_table_entry loc_service_response_messages_v02[] = {
+  {QMI_LOC_GET_SUPPORTED_MSGS_RESP_V02, QMI_IDL_TYPE16(1, 1), 8204},
+  {QMI_LOC_GET_SUPPORTED_FIELDS_RESP_V02, QMI_IDL_TYPE16(1, 3), 115},
+  {QMI_LOC_INFORM_CLIENT_REVISION_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_REG_EVENTS_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_START_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_STOP_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_GET_SERVICE_REVISION_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_GET_FIX_CRITERIA_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_NI_USER_RESPONSE_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_INJECT_PREDICTED_ORBITS_DATA_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_GET_PREDICTED_ORBITS_DATA_SOURCE_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_GET_PREDICTED_ORBITS_DATA_VALIDITY_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_INJECT_UTC_TIME_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_INJECT_POSITION_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_SET_ENGINE_LOCK_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_GET_ENGINE_LOCK_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_SET_SBAS_CONFIG_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_GET_SBAS_CONFIG_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_SET_NMEA_TYPES_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_GET_NMEA_TYPES_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_SET_LOW_POWER_MODE_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_GET_LOW_POWER_MODE_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_SET_SERVER_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_GET_SERVER_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_DELETE_ASSIST_DATA_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_SET_XTRA_T_SESSION_CONTROL_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_GET_XTRA_T_SESSION_CONTROL_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_INJECT_WIFI_POSITION_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_NOTIFY_WIFI_STATUS_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_GET_REGISTERED_EVENTS_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_SET_OPERATION_MODE_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_GET_OPERATION_MODE_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_SET_SPI_STATUS_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_INJECT_SENSOR_DATA_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_INJECT_TIME_SYNC_DATA_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_SET_CRADLE_MOUNT_CONFIG_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_GET_CRADLE_MOUNT_CONFIG_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_SET_EXTERNAL_POWER_CONFIG_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_GET_EXTERNAL_POWER_CONFIG_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_INFORM_LOCATION_SERVER_CONN_STATUS_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_SET_PROTOCOL_CONFIG_PARAMETERS_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_GET_PROTOCOL_CONFIG_PARAMETERS_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_SET_SENSOR_CONTROL_CONFIG_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_GET_SENSOR_CONTROL_CONFIG_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_SET_SENSOR_PROPERTIES_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_GET_SENSOR_PROPERTIES_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_SET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_GET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_INJECT_SUPL_CERTIFICATE_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_DELETE_SUPL_CERTIFICATE_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_SET_POSITION_ENGINE_CONFIG_PARAMETERS_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_GET_POSITION_ENGINE_CONFIG_PARAMETERS_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_ADD_CIRCULAR_GEOFENCE_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_DELETE_GEOFENCE_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_QUERY_GEOFENCE_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_EDIT_GEOFENCE_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_GET_BEST_AVAILABLE_POSITION_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_INJECT_MOTION_DATA_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_GET_NI_GEOFENCE_ID_LIST_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_INJECT_GSM_CELL_INFO_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_INJECT_NETWORK_INITIATED_MESSAGE_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_WWAN_OUT_OF_SERVICE_NOTIFICATION_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_PEDOMETER_REPORT_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_INJECT_WCDMA_CELL_INFO_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_INJECT_TDSCDMA_CELL_INFO_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_INJECT_SUBSCRIBER_ID_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_SET_GEOFENCE_ENGINE_CONFIG_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_GET_GEOFENCE_ENGINE_CONFIG_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_GET_BATCH_SIZE_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_START_BATCHING_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_READ_FROM_BATCH_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_STOP_BATCHING_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_RELEASE_BATCH_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_INJECT_WIFI_AP_DATA_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_NOTIFY_WIFI_ATTACHMENT_STATUS_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_NOTIFY_WIFI_ENABLED_STATUS_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_INJECT_VEHICLE_SENSOR_DATA_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_GET_AVAILABLE_WWAN_POSITION_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_SET_PREMIUM_SERVICES_CONFIG_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_SET_XTRA_VERSION_CHECK_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_SET_GNSS_CONSTELL_REPORT_CONFIG_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_ADD_GEOFENCE_CONTEXT_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_SET_GEOFENCE_ENGINE_CONTEXT_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_DELETE_GEOFENCE_CONTEXT_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_INJECT_GTP_CLIENT_DOWNLOADED_DATA_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_GDT_UPLOAD_BEGIN_STATUS_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_GDT_UPLOAD_END_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_START_DBT_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_STOP_DBT_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_SECURE_GET_AVAILABLE_POSITION_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_INJECT_TIME_ZONE_INFO_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_INJECT_APCACHE_DATA_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_INJECT_APDONOTCACHE_DATA_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_QUERY_AON_CONFIG_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_GTP_AP_STATUS_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_GDT_DOWNLOAD_BEGIN_STATUS_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_GDT_DOWNLOAD_READY_STATUS_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_GDT_RECEIVE_DONE_STATUS_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_GDT_DOWNLOAD_END_STATUS_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_DELETE_GNSS_SERVICE_DATA_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_INJECT_XTRA_DATA_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_INJECT_XTRA_PCID_RESP_V02, QMI_IDL_TYPE16(0, 0), 7},
+  {QMI_LOC_GET_SUPPORTED_FEATURE_RESP_V02, QMI_IDL_TYPE16(0, 0), 7}
+};
+
+static const qmi_idl_service_message_table_entry loc_service_indication_messages_v02[] = {
+  {QMI_LOC_EVENT_POSITION_REPORT_IND_V02, QMI_IDL_TYPE16(0, 5), 422},
+  {QMI_LOC_EVENT_GNSS_SV_INFO_IND_V02, QMI_IDL_TYPE16(0, 6), 2248},
+  {QMI_LOC_EVENT_NMEA_IND_V02, QMI_IDL_TYPE16(0, 7), 203},
+  {QMI_LOC_EVENT_NI_NOTIFY_VERIFY_REQ_IND_V02, QMI_IDL_TYPE16(0, 8), 1338},
+  {QMI_LOC_EVENT_INJECT_TIME_REQ_IND_V02, QMI_IDL_TYPE16(0, 9), 776},
+  {QMI_LOC_EVENT_INJECT_PREDICTED_ORBITS_REQ_IND_V02, QMI_IDL_TYPE16(0, 10), 783},
+  {QMI_LOC_EVENT_INJECT_POSITION_REQ_IND_V02, QMI_IDL_TYPE16(0, 11), 40},
+  {QMI_LOC_EVENT_ENGINE_STATE_IND_V02, QMI_IDL_TYPE16(0, 12), 7},
+  {QMI_LOC_EVENT_FIX_SESSION_STATE_IND_V02, QMI_IDL_TYPE16(0, 13), 11},
+  {QMI_LOC_EVENT_WIFI_REQ_IND_V02, QMI_IDL_TYPE16(0, 14), 16},
+  {QMI_LOC_EVENT_SENSOR_STREAMING_READY_STATUS_IND_V02, QMI_IDL_TYPE16(0, 15), 48},
+  {QMI_LOC_EVENT_TIME_SYNC_REQ_IND_V02, QMI_IDL_TYPE16(0, 16), 7},
+  {QMI_LOC_EVENT_SET_SPI_STREAMING_REPORT_IND_V02, QMI_IDL_TYPE16(0, 17), 4},
+  {QMI_LOC_EVENT_LOCATION_SERVER_CONNECTION_REQ_IND_V02, QMI_IDL_TYPE16(0, 18), 21},
+  {QMI_LOC_GET_SERVICE_REVISION_IND_V02, QMI_IDL_TYPE16(0, 33), 532},
+  {QMI_LOC_GET_FIX_CRITERIA_IND_V02, QMI_IDL_TYPE16(0, 35), 124},
+  {QMI_LOC_NI_USER_RESPONSE_IND_V02, QMI_IDL_TYPE16(0, 37), 7},
+  {QMI_LOC_INJECT_PREDICTED_ORBITS_DATA_IND_V02, QMI_IDL_TYPE16(0, 39), 12},
+  {QMI_LOC_GET_PREDICTED_ORBITS_DATA_SOURCE_IND_V02, QMI_IDL_TYPE16(0, 41), 790},
+  {QMI_LOC_GET_PREDICTED_ORBITS_DATA_VALIDITY_IND_V02, QMI_IDL_TYPE16(0, 43), 20},
+  {QMI_LOC_INJECT_UTC_TIME_IND_V02, QMI_IDL_TYPE16(0, 45), 7},
+  {QMI_LOC_INJECT_POSITION_IND_V02, QMI_IDL_TYPE16(0, 47), 7},
+  {QMI_LOC_SET_ENGINE_LOCK_IND_V02, QMI_IDL_TYPE16(0, 49), 7},
+  {QMI_LOC_GET_ENGINE_LOCK_IND_V02, QMI_IDL_TYPE16(0, 51), 14},
+  {QMI_LOC_SET_SBAS_CONFIG_IND_V02, QMI_IDL_TYPE16(0, 53), 7},
+  {QMI_LOC_GET_SBAS_CONFIG_IND_V02, QMI_IDL_TYPE16(0, 55), 11},
+  {QMI_LOC_SET_NMEA_TYPES_IND_V02, QMI_IDL_TYPE16(0, 57), 7},
+  {QMI_LOC_GET_NMEA_TYPES_IND_V02, QMI_IDL_TYPE16(0, 59), 14},
+  {QMI_LOC_SET_LOW_POWER_MODE_IND_V02, QMI_IDL_TYPE16(0, 61), 7},
+  {QMI_LOC_GET_LOW_POWER_MODE_IND_V02, QMI_IDL_TYPE16(0, 63), 11},
+  {QMI_LOC_SET_SERVER_IND_V02, QMI_IDL_TYPE16(0, 65), 7},
+  {QMI_LOC_GET_SERVER_IND_V02, QMI_IDL_TYPE16(0, 67), 304},
+  {QMI_LOC_DELETE_ASSIST_DATA_IND_V02, QMI_IDL_TYPE16(0, 69), 7},
+  {QMI_LOC_SET_XTRA_T_SESSION_CONTROL_IND_V02, QMI_IDL_TYPE16(0, 71), 7},
+  {QMI_LOC_GET_XTRA_T_SESSION_CONTROL_IND_V02, QMI_IDL_TYPE16(0, 73), 11},
+  {QMI_LOC_INJECT_WIFI_POSITION_IND_V02, QMI_IDL_TYPE16(0, 75), 7},
+  {QMI_LOC_NOTIFY_WIFI_STATUS_IND_V02, QMI_IDL_TYPE16(0, 77), 7},
+  {QMI_LOC_GET_REGISTERED_EVENTS_IND_V02, QMI_IDL_TYPE16(0, 79), 18},
+  {QMI_LOC_SET_OPERATION_MODE_IND_V02, QMI_IDL_TYPE16(0, 81), 7},
+  {QMI_LOC_GET_OPERATION_MODE_IND_V02, QMI_IDL_TYPE16(0, 83), 14},
+  {QMI_LOC_SET_SPI_STATUS_IND_V02, QMI_IDL_TYPE16(0, 85), 7},
+  {QMI_LOC_INJECT_SENSOR_DATA_IND_V02, QMI_IDL_TYPE16(0, 87), 34},
+  {QMI_LOC_INJECT_TIME_SYNC_DATA_IND_V02, QMI_IDL_TYPE16(0, 89), 7},
+  {QMI_LOC_SET_CRADLE_MOUNT_CONFIG_IND_V02, QMI_IDL_TYPE16(0, 93), 7},
+  {QMI_LOC_GET_CRADLE_MOUNT_CONFIG_IND_V02, QMI_IDL_TYPE16(0, 91), 18},
+  {QMI_LOC_SET_EXTERNAL_POWER_CONFIG_IND_V02, QMI_IDL_TYPE16(0, 97), 7},
+  {QMI_LOC_GET_EXTERNAL_POWER_CONFIG_IND_V02, QMI_IDL_TYPE16(0, 95), 14},
+  {QMI_LOC_INFORM_LOCATION_SERVER_CONN_STATUS_IND_V02, QMI_IDL_TYPE16(0, 99), 7},
+  {QMI_LOC_SET_PROTOCOL_CONFIG_PARAMETERS_IND_V02, QMI_IDL_TYPE16(0, 101), 18},
+  {QMI_LOC_GET_PROTOCOL_CONFIG_PARAMETERS_IND_V02, QMI_IDL_TYPE16(0, 103), 86},
+  {QMI_LOC_SET_SENSOR_CONTROL_CONFIG_IND_V02, QMI_IDL_TYPE16(0, 105), 7},
+  {QMI_LOC_GET_SENSOR_CONTROL_CONFIG_IND_V02, QMI_IDL_TYPE16(0, 107), 21},
+  {QMI_LOC_SET_SENSOR_PROPERTIES_IND_V02, QMI_IDL_TYPE16(0, 109), 14},
+  {QMI_LOC_GET_SENSOR_PROPERTIES_IND_V02, QMI_IDL_TYPE16(0, 111), 95},
+  {QMI_LOC_SET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_IND_V02, QMI_IDL_TYPE16(0, 113), 14},
+  {QMI_LOC_GET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_IND_V02, QMI_IDL_TYPE16(0, 115), 49},
+  {QMI_LOC_INJECT_SUPL_CERTIFICATE_IND_V02, QMI_IDL_TYPE16(0, 117), 7},
+  {QMI_LOC_DELETE_SUPL_CERTIFICATE_IND_V02, QMI_IDL_TYPE16(0, 119), 7},
+  {QMI_LOC_SET_POSITION_ENGINE_CONFIG_PARAMETERS_IND_V02, QMI_IDL_TYPE16(0, 121), 14},
+  {QMI_LOC_GET_POSITION_ENGINE_CONFIG_PARAMETERS_IND_V02, QMI_IDL_TYPE16(0, 123), 23},
+  {QMI_LOC_EVENT_NI_GEOFENCE_NOTIFICATION_IND_V02, QMI_IDL_TYPE16(0, 19), 14},
+  {QMI_LOC_EVENT_GEOFENCE_GEN_ALERT_IND_V02, QMI_IDL_TYPE16(0, 20), 7},
+  {QMI_LOC_EVENT_GEOFENCE_BREACH_NOTIFICATION_IND_V02, QMI_IDL_TYPE16(0, 21), 85},
+  {QMI_LOC_ADD_CIRCULAR_GEOFENCE_IND_V02, QMI_IDL_TYPE16(0, 125), 21},
+  {QMI_LOC_DELETE_GEOFENCE_IND_V02, QMI_IDL_TYPE16(0, 127), 21},
+  {QMI_LOC_QUERY_GEOFENCE_IND_V02, QMI_IDL_TYPE16(0, 129), 65},
+  {QMI_LOC_EDIT_GEOFENCE_IND_V02, QMI_IDL_TYPE16(0, 135), 28},
+  {QMI_LOC_GET_BEST_AVAILABLE_POSITION_IND_V02, QMI_IDL_TYPE16(0, 140), 391},
+  {QMI_LOC_INJECT_MOTION_DATA_IND_V02, QMI_IDL_TYPE16(0, 142), 7},
+  {QMI_LOC_GET_NI_GEOFENCE_ID_LIST_IND_V02, QMI_IDL_TYPE16(0, 144), 82},
+  {QMI_LOC_INJECT_GSM_CELL_INFO_IND_V02, QMI_IDL_TYPE16(0, 146), 7},
+  {QMI_LOC_INJECT_NETWORK_INITIATED_MESSAGE_IND_V02, QMI_IDL_TYPE16(0, 154), 7},
+  {QMI_LOC_WWAN_OUT_OF_SERVICE_NOTIFICATION_IND_V02, QMI_IDL_TYPE16(0, 156), 7},
+  {QMI_LOC_EVENT_PEDOMETER_CONTROL_IND_V02, QMI_IDL_TYPE16(0, 22), 15},
+  {QMI_LOC_EVENT_MOTION_DATA_CONTROL_IND_V02, QMI_IDL_TYPE16(0, 23), 4},
+  {QMI_LOC_PEDOMETER_REPORT_IND_V02, QMI_IDL_TYPE16(0, 158), 7},
+  {QMI_LOC_INJECT_WCDMA_CELL_INFO_IND_V02, QMI_IDL_TYPE16(0, 148), 7},
+  {QMI_LOC_INJECT_TDSCDMA_CELL_INFO_IND_V02, QMI_IDL_TYPE16(0, 150), 7},
+  {QMI_LOC_INJECT_SUBSCRIBER_ID_IND_V02, QMI_IDL_TYPE16(0, 152), 7},
+  {QMI_LOC_SET_GEOFENCE_ENGINE_CONFIG_IND_V02, QMI_IDL_TYPE16(0, 131), 14},
+  {QMI_LOC_GET_GEOFENCE_ENGINE_CONFIG_IND_V02, QMI_IDL_TYPE16(0, 133), 39},
+  {QMI_LOC_GET_BATCH_SIZE_IND_V02, QMI_IDL_TYPE16(0, 160), 21},
+  {QMI_LOC_START_BATCHING_IND_V02, QMI_IDL_TYPE16(0, 162), 14},
+  {QMI_LOC_EVENT_BATCH_FULL_NOTIFICATION_IND_V02, QMI_IDL_TYPE16(0, 163), 7},
+  {QMI_LOC_EVENT_LIVE_BATCHED_POSITION_REPORT_IND_V02, QMI_IDL_TYPE16(0, 164), 90},
+  {QMI_LOC_READ_FROM_BATCH_IND_V02, QMI_IDL_TYPE16(0, 166), 460},
+  {QMI_LOC_STOP_BATCHING_IND_V02, QMI_IDL_TYPE16(0, 168), 21},
+  {QMI_LOC_RELEASE_BATCH_IND_V02, QMI_IDL_TYPE16(0, 170), 14},
+  {QMI_LOC_EVENT_INJECT_WIFI_AP_DATA_REQ_IND_V02, QMI_IDL_TYPE16(0, 171), 4},
+  {QMI_LOC_INJECT_WIFI_AP_DATA_IND_V02, QMI_IDL_TYPE16(0, 173), 7},
+  {QMI_LOC_NOTIFY_WIFI_ATTACHMENT_STATUS_IND_V02, QMI_IDL_TYPE16(0, 175), 7},
+  {QMI_LOC_NOTIFY_WIFI_ENABLED_STATUS_IND_V02, QMI_IDL_TYPE16(0, 177), 7},
+  {QMI_LOC_EVENT_GEOFENCE_BATCHED_BREACH_NOTIFICATION_IND_V02, QMI_IDL_TYPE16(0, 24), 1254},
+  {QMI_LOC_EVENT_VEHICLE_DATA_READY_STATUS_IND_V02, QMI_IDL_TYPE16(0, 178), 12},
+  {QMI_LOC_INJECT_VEHICLE_SENSOR_DATA_IND_V02, QMI_IDL_TYPE16(0, 180), 7},
+  {QMI_LOC_GET_AVAILABLE_WWAN_POSITION_IND_V02, QMI_IDL_TYPE16(0, 182), 145},
+  {QMI_LOC_SET_PREMIUM_SERVICES_CONFIG_IND_V02, QMI_IDL_TYPE16(0, 184), 7},
+  {QMI_LOC_SET_XTRA_VERSION_CHECK_IND_V02, QMI_IDL_TYPE16(0, 186), 7},
+  {QMI_LOC_EVENT_GNSS_MEASUREMENT_REPORT_IND_V02, QMI_IDL_TYPE16(0, 189), 1617},
+  {QMI_LOC_EVENT_SV_POLYNOMIAL_REPORT_IND_V02, QMI_IDL_TYPE16(0, 190), 325},
+  {QMI_LOC_SET_GNSS_CONSTELL_REPORT_CONFIG_IND_V02, QMI_IDL_TYPE16(0, 188), 7},
+  {QMI_LOC_ADD_GEOFENCE_CONTEXT_IND_V02, QMI_IDL_TYPE16(0, 192), 28},
+  {QMI_LOC_SET_GEOFENCE_ENGINE_CONTEXT_IND_V02, QMI_IDL_TYPE16(0, 194), 14},
+  {QMI_LOC_DELETE_GEOFENCE_CONTEXT_IND_V02, QMI_IDL_TYPE16(0, 196), 28},
+  {QMI_LOC_EVENT_GEOFENCE_PROXIMITY_NOTIFICATION_IND_V02, QMI_IDL_TYPE16(0, 25), 21},
+  {QMI_LOC_INJECT_GTP_CLIENT_DOWNLOADED_DATA_IND_V02, QMI_IDL_TYPE16(0, 198), 7},
+  {QMI_LOC_GDT_UPLOAD_BEGIN_STATUS_IND_V02, QMI_IDL_TYPE16(0, 200), 7},
+  {QMI_LOC_GDT_UPLOAD_END_IND_V02, QMI_IDL_TYPE16(0, 202), 7},
+  {QMI_LOC_EVENT_GDT_UPLOAD_BEGIN_STATUS_REQ_IND_V02, QMI_IDL_TYPE16(0, 27), 273},
+  {QMI_LOC_EVENT_GDT_UPLOAD_END_REQ_IND_V02, QMI_IDL_TYPE16(0, 28), 21},
+  {QMI_LOC_START_DBT_IND_V02, QMI_IDL_TYPE16(0, 214), 11},
+  {QMI_LOC_EVENT_DBT_POSITION_REPORT_IND_V02, QMI_IDL_TYPE16(0, 217), 283},
+  {QMI_LOC_EVENT_DBT_SESSION_STATUS_IND_V02, QMI_IDL_TYPE16(0, 218), 11},
+  {QMI_LOC_STOP_DBT_IND_V02, QMI_IDL_TYPE16(0, 216), 11},
+  {QMI_LOC_SECURE_GET_AVAILABLE_POSITION_IND_V02, QMI_IDL_TYPE16(0, 220), 1043},
+  {QMI_LOC_EVENT_GEOFENCE_BATCHED_DWELL_NOTIFICATION_IND_V02, QMI_IDL_TYPE16(0, 26), 1247},
+  {QMI_LOC_EVENT_GET_TIME_ZONE_INFO_IND_V02, QMI_IDL_TYPE16(0, 136), 7},
+  {QMI_LOC_INJECT_TIME_ZONE_INFO_IND_V02, QMI_IDL_TYPE16(0, 138), 7},
+  {QMI_LOC_INJECT_APCACHE_DATA_IND_V02, QMI_IDL_TYPE16(0, 222), 70},
+  {QMI_LOC_INJECT_APDONOTCACHE_DATA_IND_V02, QMI_IDL_TYPE16(0, 224), 7},
+  {QMI_LOC_EVENT_BATCHING_STATUS_IND_V02, QMI_IDL_TYPE16(0, 225), 7},
+  {QMI_LOC_QUERY_AON_CONFIG_IND_V02, QMI_IDL_TYPE16(0, 227), 21},
+  {QMI_LOC_GTP_AP_STATUS_IND_V02, QMI_IDL_TYPE16(0, 204), 18},
+  {QMI_LOC_GDT_DOWNLOAD_BEGIN_STATUS_IND_V02, QMI_IDL_TYPE16(0, 206), 7},
+  {QMI_LOC_GDT_DOWNLOAD_READY_STATUS_IND_V02, QMI_IDL_TYPE16(0, 208), 7},
+  {QMI_LOC_GDT_RECEIVE_DONE_STATUS_IND_V02, QMI_IDL_TYPE16(0, 210), 7},
+  {QMI_LOC_GDT_DOWNLOAD_END_STATUS_IND_V02, QMI_IDL_TYPE16(0, 212), 7},
+  {QMI_LOC_EVENT_GDT_DOWNLOAD_BEGIN_REQ_IND_V02, QMI_IDL_TYPE16(0, 29), 5811},
+  {QMI_LOC_EVENT_GDT_RECEIVE_DONE_IND_V02, QMI_IDL_TYPE16(0, 30), 21},
+  {QMI_LOC_EVENT_GDT_DOWNLOAD_END_REQ_IND_V02, QMI_IDL_TYPE16(0, 31), 21},
+  {QMI_LOC_DELETE_GNSS_SERVICE_DATA_IND_V02, QMI_IDL_TYPE16(0, 229), 7},
+  {QMI_LOC_INJECT_XTRA_DATA_IND_V02, QMI_IDL_TYPE16(0, 231), 12},
+  {QMI_LOC_INJECT_XTRA_PCID_IND_V02, QMI_IDL_TYPE16(0, 233), 7},
+  {QMI_LOC_GET_SUPPORTED_FEATURE_IND_V02, QMI_IDL_TYPE16(0, 235), 111}
+};
+
+/*Service Object*/
+struct qmi_idl_service_object loc_qmi_idl_service_object_v02 = {
+  0x06,
+  0x02,
+  0x10,
+  8204,
+  { sizeof(loc_service_command_messages_v02)/sizeof(qmi_idl_service_message_table_entry),
+    sizeof(loc_service_response_messages_v02)/sizeof(qmi_idl_service_message_table_entry),
+    sizeof(loc_service_indication_messages_v02)/sizeof(qmi_idl_service_message_table_entry) },
+  { loc_service_command_messages_v02, loc_service_response_messages_v02, loc_service_indication_messages_v02},
+  &loc_qmi_idl_type_table_object_v02,
+  0x39,
+  NULL
+};
+
+/* Service Object Accessor */
+qmi_idl_service_object_type loc_get_service_object_internal_v02
+ ( int32_t idl_maj_version, int32_t idl_min_version, int32_t library_version ){
+  if ( LOC_V02_IDL_MAJOR_VERS != idl_maj_version || LOC_V02_IDL_MINOR_VERS != idl_min_version
+       || LOC_V02_IDL_TOOL_VERS != library_version)
+  {
+    return NULL;
+  }
+  return (qmi_idl_service_object_type)&loc_qmi_idl_service_object_v02;
+}
+
diff --git a/gps/loc_api/loc_api_v02/location_service_v02.h b/gps/loc_api/loc_api_v02/location_service_v02.h
new file mode 100644
index 0000000..d1fdbf8
--- /dev/null
+++ b/gps/loc_api/loc_api_v02/location_service_v02.h
@@ -0,0 +1,16657 @@
+/* Copyright (c) 2011-2016, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of The Linux Foundation, nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef LOC_SERVICE_02_H
+#define LOC_SERVICE_02_H
+/**
+  @file location_service_v02.h
+
+  @brief This is the public header file which defines the loc service Data structures.
+
+  This header file defines the types and structures that were defined in
+  loc. It contains the constant values defined, enums, structures,
+  messages, and service message IDs (in that order) Structures that were
+  defined in the IDL as messages contain mandatory elements, optional
+  elements, a combination of mandatory and optional elements (mandatory
+  always come before optionals in the structure), or nothing (null message)
+
+  An optional element in a message is preceded by a uint8_t value that must be
+  set to true if the element is going to be included. When decoding a received
+  message, the uint8_t values will be set to true or false by the decode
+  routine, and should be checked before accessing the values that they
+  correspond to.
+
+  Variable sized arrays are defined as static sized arrays with an unsigned
+  integer (32 bit) preceding it that must be set to the number of elements
+  in the array that are valid. For Example:
+
+  uint32_t test_opaque_len;
+  uint8_t test_opaque[16];
+
+  If only 4 elements are added to test_opaque[] then test_opaque_len must be
+  set to 4 before sending the message.  When decoding, the _len value is set
+  by the decode routine and should be checked so that the correct number of
+  elements in the array will be accessed.
+
+*/
+/*====*====*====*====*====*====*====*====*====*====*====*====*====*====*====*
+ *THIS IS AN AUTO GENERATED FILE. DO NOT ALTER IN ANY WAY
+ *====*====*====*====*====*====*====*====*====*====*====*====*====*====*====*/
+
+/* This file was generated with Tool version 6.14.7
+   It was generated on: Tue Jun 28 2016 (Spin 0)
+   From IDL File: location_service_v02.idl */
+
+/** @defgroup loc_qmi_consts Constant values defined in the IDL */
+/** @defgroup loc_qmi_msg_ids Constant values for QMI message IDs */
+/** @defgroup loc_qmi_enums Enumerated types used in QMI messages */
+/** @defgroup loc_qmi_messages Structures sent as QMI messages */
+/** @defgroup loc_qmi_aggregates Aggregate types used in QMI messages */
+/** @defgroup loc_qmi_accessor Accessor for QMI service object */
+/** @defgroup loc_qmi_version Constant values for versioning information */
+
+#include <stdint.h>
+#include "qmi_idl_lib.h"
+#include "common_v01.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** @addtogroup loc_qmi_version
+    @{
+  */
+/** Major Version Number of the IDL used to generate this file */
+#define LOC_V02_IDL_MAJOR_VERS 0x02
+/** Revision Number of the IDL used to generate this file */
+#define LOC_V02_IDL_MINOR_VERS 0x39
+/** Major Version Number of the qmi_idl_compiler used to generate this file */
+#define LOC_V02_IDL_TOOL_VERS 0x06
+/** Maximum Defined Message ID */
+#define LOC_V02_MAX_MESSAGE_ID 0x00A9
+/**
+    @}
+  */
+
+
+/** @addtogroup loc_qmi_consts
+    @{
+  */
+
+/**  Maximum string length for the Provider field in the application ID.  */
+#define QMI_LOC_MAX_APP_ID_PROVIDER_LENGTH_V02 24
+
+/**  Maximum string length for the Name field in the application ID.  */
+#define QMI_LOC_MAX_APP_ID_NAME_LENGTH_V02 32
+
+/**  Maximum string length for the Version field in the application ID.  */
+#define QMI_LOC_MAX_APP_ID_VERSION_LENGTH_V02 8
+
+/**  Maximum length of the list containing the SVs that were used to generate
+     a position report.  */
+#define QMI_LOC_MAX_SV_USED_LIST_LENGTH_V02 80
+
+/**  East, North, Up array length  */
+#define QMI_LOC_ENU_ARRAY_LENGTH_V02 3
+
+/**  Maximum number of satellites in the satellite report.  */
+#define QMI_LOC_SV_INFO_LIST_MAX_SIZE_V02 80
+
+/**  Maximum NMEA string length.  */
+#define QMI_LOC_NMEA_STRING_MAX_LENGTH_V02 200
+
+/**  Maximum length of the requestor ID string.  */
+#define QMI_LOC_NI_MAX_REQUESTOR_ID_LENGTH_V02 200
+
+/**  Session ID byte length.  */
+#define QMI_LOC_NI_SUPL_SLP_SESSION_ID_BYTE_LENGTH_V02 4
+
+/**  Maximum client name length allowed.  */
+#define QMI_LOC_NI_MAX_CLIENT_NAME_LENGTH_V02 64
+
+/**  Maximum URL length accepted by the location engine.  */
+#define QMI_LOC_MAX_SERVER_ADDR_LENGTH_V02 255
+
+/**  IPv6 address length in bytes.  */
+#define QMI_LOC_IPV6_ADDR_LENGTH_V02 8
+
+/**  SUPL hash length.  */
+#define QMI_LOC_NI_SUPL_HASH_LENGTH_V02 8
+
+/**  Maximum client address length allowed.  */
+#define QMI_LOC_NI_MAX_EXT_CLIENT_ADDRESS_V02 20
+
+/**  Maximum codeword length allowed.  */
+#define QMI_LOC_NI_CODEWORD_MAX_LENGTH_V02 20
+
+/**  Maximum number of NTP Servers sent out with this event. */
+#define QMI_LOC_MAX_NTP_SERVERS_V02 3
+
+/**  Maximum number of predicted orbits servers supported in the location
+     engine.  */
+#define QMI_LOC_MAX_PREDICTED_ORBITS_SERVERS_V02 3
+
+/**  Maximum length of the list, where each element of the list contains the
+     continuous range of Geofences that were breached at a given position.  */
+#define QMI_LOC_MAX_GEOFENCE_ID_CONTINUOUS_LIST_LENGTH_V02 80
+
+/**  Maximum length of the list that contains a discrete number Geofences that
+     were breached at a given position.  */
+#define QMI_LOC_MAX_GEOFENCE_ID_DISCRETE_LIST_LENGTH_V02 80
+
+/**  Maximum length that can be injected.   */
+#define QMI_LOC_MAX_GDT_PATH_LEN_V02 255
+
+/**  Maximum client information size in bytes.   */
+#define QMI_LOC_MAX_GTP_CL_INFO_LEN_V02 1500
+
+/**  Maximum mobile status data size in bytes.   */
+#define QMI_LOC_MAX_GTP_MSD_LEN_V02 4000
+
+/**  Maximum GNSS Measurement Engine Firmware Version String length.  */
+#define QMI_LOC_GNSS_ME_VERSION_STRING_MAX_LENGTH_V02 127
+
+/**  Maximum GNSS Measurement Engine Hosted Software Version String length.  */
+#define QMI_LOC_GNSS_HOSTED_SW_VERSION_STRING_MAX_LENGTH_V02 127
+
+/**  Maximum GNSS Measurement Engine Full Version String length.  */
+#define QMI_LOC_GNSS_SW_VERSION_STRING_MAX_LENGTH_V02 255
+
+/**  Maximum part length that can be injected. The client should
+     also look at the maxPartSize field in the predicted orbits injection
+     request indication and pick the minimum of the two.  */
+#define QMI_LOC_MAX_PREDICTED_ORBITS_PART_LEN_V02 1024
+
+/**  Maximum length of the delete SV information list  */
+#define QMI_LOC_DELETE_MAX_SV_INFO_LENGTH_V02 128
+
+/**  Maximum length of the Delete BDS SV Information list.  */
+#define QMI_LOC_DELETE_MAX_BDS_SV_INFO_LENGTH_V02 37
+
+/**  Maximum length of the Delete GAL SV Information list.  */
+#define QMI_LOC_DELETE_MAX_GAL_SV_INFO_LENGTH_V02 36
+
+/**  MAC address length in bytes.  */
+#define QMI_LOC_WIFI_MAC_ADDR_LENGTH_V02 6
+
+/**  Wi-Fi SSID string maximum length.   */
+#define QMI_LOC_MAX_WIFI_AP_SSID_STR_LENGTH_V02 32
+
+/**  Maximum number of APs that the sender can report.  */
+#define QMI_LOC_WIFI_MAX_REPORTED_APS_PER_MSG_V02 50
+
+/**  Maximum number of samples that can be injected in a TLV.  */
+#define QMI_LOC_SENSOR_DATA_MAX_SAMPLES_V02 50
+
+/**  Maximum APN string length allowed.  */
+#define QMI_LOC_MAX_APN_NAME_LENGTH_V02 100
+
+/**  Maximum APN profiles supported. */
+#define QMI_LOC_MAX_APN_PROFILES_V02 6
+
+/**  Maximum length of the SUPL certificate. */
+#define QMI_LOC_MAX_SUPL_CERT_LENGTH_V02 2000
+
+/**  Maximum number of motion states used by the Geofence engine.  */
+#define QMI_LOC_GEOFENCE_MAX_MOTION_STATES_V02 20
+
+/**  Maximum length of the network-initiated Geofence ID
+     list.  */
+#define QMI_LOC_MAX_NI_GEOFENCE_ID_LIST_LENGTH_V02 16
+
+/**  Maximum value of WDMA frequency for injection of WCDMA cell
+     information.  */
+#define QMI_LOC_MAX_WCDMA_FREQ_V02 16383
+
+/**  Maximum value of PSC for injection of WCDMA cell information.  */
+#define QMI_LOC_MAX_WCDMA_PSC_V02 511
+
+/**  Maximum value of TDSCDMA frequency for injection of TDSCDMA cell
+     information.  */
+#define QMI_LOC_MAX_TDSCDMA_FREQ_V02 16383
+
+/**  Maximum length of the injected network-initiated message.  */
+#define QMI_LOC_MAX_INJECTED_NETWORK_INITIATED_MESSAGE_LENGTH_V02 1024
+
+/**  Maximum number of entries returned from a batch in each indication.  */
+#define QMI_LOC_READ_FROM_BATCH_MAX_SIZE_V02 5
+
+/**  Maximum number of vehicle sensor samples that can be injected.  */
+#define QMI_LOC_VEHICLE_SENSOR_DATA_MAX_SAMPLES_V02 65
+
+/**  Maximum number of axes that can be provided in each sample.  */
+#define QMI_LOC_VEHICLE_SENSOR_DATA_MAX_AXES_V02 3
+
+/**  Maximum number of measurements from an odometer.  */
+#define QMI_LOC_VEHICLE_ODOMETRY_MAX_MEASUREMENTS_V02 3
+#define QMI_LOC_MEAS_STATUS_DONT_USE_BITS_V02 0xFFC0000000000000
+
+/**  Maximum number of satellites in a measurement block for a given system.  */
+#define QMI_LOC_SV_MEAS_LIST_MAX_SIZE_V02 16
+#define QMI_LOC_SV_POLY_VELOCITY_COEF_SIZE_V02 12
+#define QMI_LOC_SV_POLY_XYZ_0_TH_ORDER_COEFF_SIZE_V02 3
+#define QMI_LOC_SV_POLY_XYZ_N_TH_ORDER_COEFF_SIZE_V02 9
+#define QMI_LOC_SV_POLY_SV_CLKBIAS_COEFF_SIZE_V02 4
+
+/**  IBeacon string maximum length.   */
+#define QMI_LOC_MAX_IBEACON_UUID_STR_LENGTH_V02 32
+
+/**  Wi-Fi area ID list length.  */
+#define QMI_LOC_WIFI_AREA_ID_LIST_LENGTH_V02 20
+
+/**  Cell ID list length.   */
+#define QMI_LOC_CELL_ID_LIST_LENGTH_V02 20
+
+/**   IBeacon list length.   */
+#define QMI_LOC_IBEACON_LIST_LENGTH_V02 20
+
+/**  Maximum length that can be injected.   */
+#define QMI_LOC_MAX_GTP_WWAN_CLIENT_DOWNLOADED_DATA_LEN_V02 512
+
+/**  Maximum length of OEM id.  */
+#define QMI_LOC_MAX_OEM_ID_LEN_V02 256
+
+/**  Maximum length of model id.  */
+#define QMI_LOC_MAX_MODEL_ID_LEN_V02 256
+
+/**  Maximum length that can be injected.   */
+#define QMI_LOC_MAX_GTP_RLI_LEN_V02 256
+
+/**  Maximum buffer length of the encrypted data blob for the Secure Get Available Position request. */
+#define QMI_LOC_SECURE_GET_AVAILABLE_POS_REQUEST_ENCRYPTED_MAX_V02 256
+
+/**  Horizontal Uncertainty Circular
+ Altitude With Respect to Ellipsoid
+ Vertical Uncertainty
+ Horizontal Elliptical Uncertainty (Semi-Minor Axis)
+ Horizontal Elliptical Uncertainty (Semi-Major Axis)
+ Elliptical Horizontal Uncertainty Azimuth
+ Horizontal Confidence
+ Horizontal Elliptical Uncertainty Confidence
+ Horizontal Reliability
+ Horizontal Speed
+ Horizontal Speed Uncertainty
+ Altitude With Respect to Sea Level
+ Vertical Confidence
+ Vertical Reliability
+ Vertical Speed
+ Vertical Speed Uncertainty
+ Heading
+ Heading Uncertainty
+ Magnetic Deviation
+ Technology Used
+ Position Dilution of Precision
+ Horizontal Dilution of Precision
+ Vertical Dilution of Precision
+ GPS Week
+ GPS Time of Week MS
+ Time Source
+ Sensor Data Usage MASK
+ Position Data Aided by Sensor
+ SVs Used to Calculate the Fix */
+#define QMI_LOC_SECURE_GET_AVAILABLE_POSITION_IND_ENCRYPTED_MAX_V02 1024
+
+/**  Maximum number of APs that can be injected in a TLV.  */
+#define QMI_LOC_APCACHE_DATA_MAX_SAMPLES_V02 80
+
+/**  Maximum part length that can be injected. The client should
+     also look at the maxPartSize field in the predicted orbits injection
+     request indication and pick the minimum of the two.  */
+#define QMI_LOC_MAX_XTRA_PART_LEN_V02 1024
+#define QMI_LOC_SUPPORTED_FEATURE_LENGTH_V02 100
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Response Message; Generic response definition. This message is used to tell
+                    clients whether their message was accepted for further
+                    processing or rejected. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Result Code */
+  qmi_response_type_v01 resp;
+}qmiLocGenRespMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Informs the service of the minor revision of the interface
+                    definition that the control point implements. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Revision */
+  uint32_t revision;
+  /**<   Revision that the control point is using. */
+}qmiLocInformClientRevisionReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+typedef uint64_t qmiLocEventRegMaskT_v02;
+#define QMI_LOC_EVENT_MASK_POSITION_REPORT_V02 ((qmiLocEventRegMaskT_v02)0x00000001ull) /**<  The control point must enable this mask to receive position report
+       event indications.  */
+#define QMI_LOC_EVENT_MASK_GNSS_SV_INFO_V02 ((qmiLocEventRegMaskT_v02)0x00000002ull) /**<  The control point must enable this mask to receive satellite report
+       event indications. These reports are sent at a 1 Hz rate.  */
+#define QMI_LOC_EVENT_MASK_NMEA_V02 ((qmiLocEventRegMaskT_v02)0x00000004ull) /**<  The control point must enable this mask to receive NMEA reports for
+       position and satellites in view. The report is at a 1 Hz rate.  */
+#define QMI_LOC_EVENT_MASK_NI_NOTIFY_VERIFY_REQ_V02 ((qmiLocEventRegMaskT_v02)0x00000008ull) /**<  The control point must enable this mask to receive NI Notify/Verify request
+       event indications.  */
+#define QMI_LOC_EVENT_MASK_INJECT_TIME_REQ_V02 ((qmiLocEventRegMaskT_v02)0x00000010ull) /**<  The control point must enable this mask to receive time injection request
+       event indications.  */
+#define QMI_LOC_EVENT_MASK_INJECT_PREDICTED_ORBITS_REQ_V02 ((qmiLocEventRegMaskT_v02)0x00000020ull) /**<  The control point must enable this mask to receive predicted orbits request
+       event indications.  */
+#define QMI_LOC_EVENT_MASK_INJECT_POSITION_REQ_V02 ((qmiLocEventRegMaskT_v02)0x00000040ull) /**<  The control point must enable this mask to receive position injection request
+       event indications.  */
+#define QMI_LOC_EVENT_MASK_ENGINE_STATE_V02 ((qmiLocEventRegMaskT_v02)0x00000080ull) /**<  The control point must enable this mask to receive engine state report
+       event indications.  */
+#define QMI_LOC_EVENT_MASK_FIX_SESSION_STATE_V02 ((qmiLocEventRegMaskT_v02)0x00000100ull) /**<  The control point must enable this mask to receive fix session status report
+       event indications.  */
+#define QMI_LOC_EVENT_MASK_WIFI_REQ_V02 ((qmiLocEventRegMaskT_v02)0x00000200ull) /**<  The control point must enable this mask to receive Wi-Fi position request
+       event indications.  */
+#define QMI_LOC_EVENT_MASK_SENSOR_STREAMING_READY_STATUS_V02 ((qmiLocEventRegMaskT_v02)0x00000400ull) /**<  The control point must enable this mask to receive notifications from the
+       location engine indicating its readiness to accept data from the
+       sensors (accelerometer, gyroscope, etc.).  */
+#define QMI_LOC_EVENT_MASK_TIME_SYNC_REQ_V02 ((qmiLocEventRegMaskT_v02)0x00000800ull) /**<  The control point must enable this mask to receive time sync requests
+       from the GPS engine. Time sync enables the GPS engine to synchronize
+       its clock with the sensor processor's clock.  */
+#define QMI_LOC_EVENT_MASK_SET_SPI_STREAMING_REPORT_V02 ((qmiLocEventRegMaskT_v02)0x00001000ull) /**<  The control point must enable this mask to receive Stationary Position
+       Indicator (SPI) streaming report indications.  */
+#define QMI_LOC_EVENT_MASK_LOCATION_SERVER_CONNECTION_REQ_V02 ((qmiLocEventRegMaskT_v02)0x00002000ull) /**<  The control point must enable this mask to receive location server
+       requests. These requests are generated when the service wishes to
+       establish a connection with a location server. */
+#define QMI_LOC_EVENT_MASK_NI_GEOFENCE_NOTIFICATION_V02 ((qmiLocEventRegMaskT_v02)0x00004000ull) /**<  The control point must enable this mask to receive notifications
+       related to network-initiated Geofences. These events notify the client
+       when a network-initiated Geofence is added, deleted, or edited.  */
+#define QMI_LOC_EVENT_MASK_GEOFENCE_GEN_ALERT_V02 ((qmiLocEventRegMaskT_v02)0x00008000ull) /**<  The control point must enable this mask to receive Geofence alerts.
+       These alerts are generated to inform the client of the changes that may
+       affect a Geofence, e.g., if GPS is turned off or if the network is
+       unavailable.  */
+#define QMI_LOC_EVENT_MASK_GEOFENCE_BREACH_NOTIFICATION_V02 ((qmiLocEventRegMaskT_v02)0x00010000ull) /**<  The control point must enable this mask to receive notifications when
+       a Geofence is breached. These events are generated when a UE enters
+       or leaves the perimeter of a Geofence. This breach report is for a single
+       Geofence . */
+#define QMI_LOC_EVENT_MASK_PEDOMETER_CONTROL_V02 ((qmiLocEventRegMaskT_v02)0x00020000ull) /**<  The control point must enable this mask to register for pedometer
+       control requests from the location engine. The location engine sends
+       this event to control the injection of pedometer reports.  */
+#define QMI_LOC_EVENT_MASK_MOTION_DATA_CONTROL_V02 ((qmiLocEventRegMaskT_v02)0x00040000ull) /**<  The control point must enable this mask to register for motion data
+       control requests from the location engine. The location engine sends
+       this event to control the injection of motion data.  */
+#define QMI_LOC_EVENT_MASK_BATCH_FULL_NOTIFICATION_V02 ((qmiLocEventRegMaskT_v02)0x00080000ull) /**<  The control point must enable this mask to receive notification when
+       a batch is full. The location engine sends this event to notify of Batch Full
+       for ongoing batching session.  */
+#define QMI_LOC_EVENT_MASK_LIVE_BATCHED_POSITION_REPORT_V02 ((qmiLocEventRegMaskT_v02)0x00100000ull) /**<  The control point must enable this mask to receive position report
+       indications along with an ongoing batching session. The location engine sends
+       this event to notify the batched position report while a batching session
+       is ongoing.  */
+#define QMI_LOC_EVENT_MASK_INJECT_WIFI_AP_DATA_REQ_V02 ((qmiLocEventRegMaskT_v02)0x00200000ull) /**<  The control point must enable this mask to receive Wi-Fi AP data inject request
+       event indications.  */
+#define QMI_LOC_EVENT_MASK_GEOFENCE_BATCH_BREACH_NOTIFICATION_V02 ((qmiLocEventRegMaskT_v02)0x00400000ull) /**<  The control point must enable this mask to receive notifications when
+       a Geofence is breached. These events are generated when a UE enters
+       or leaves the perimeter of a Geofence. This breach notification is for
+       multiple Geofences. Breaches from multiple Geofences are all batched and
+       sent in the same notification .    */
+#define QMI_LOC_EVENT_MASK_VEHICLE_DATA_READY_STATUS_V02 ((qmiLocEventRegMaskT_v02)0x00800000ull) /**<  The control point must enable this mask to receive notifications from the
+       location engine indicating its readiness to accept vehicle data (vehicle
+       accelerometer, vehicle angular rate, vehicle odometry, etc.). */
+#define QMI_LOC_EVENT_MASK_GNSS_MEASUREMENT_REPORT_V02 ((qmiLocEventRegMaskT_v02)0x01000000ull) /**<  The control point must enable this mask to receive system clock and satellite
+       measurement report events (system clock, SV time, Doppler, etc.). Reports are
+       generated only for the GNSS satellite constellations that are enabled using
+       QMI_LOC_SET_GNSS_CONSTELL_REPORT_CONFIG.   */
+#define QMI_LOC_EVENT_MASK_GNSS_SV_POLYNOMIAL_REPORT_V02 ((qmiLocEventRegMaskT_v02)0x02000000ull) /**<  The control point must enable this mask to receive satellite position
+        reports as polynomials. Reports are generated only for the GNSS satellite
+        constellations that are enabled using QMI_LOC_SET_GNSS_CONSTELL_REPORT_CONFIG.  */
+#define QMI_LOC_EVENT_MASK_GEOFENCE_PROXIMITY_NOTIFICATION_V02 ((qmiLocEventRegMaskT_v02)0x04000000ull) /**<  The control point must enable this mask to receive notifications when a Geofence proximity is entered
+  and exited. The proximity of a Geofence may be due to different contexts. These contexts are identified
+  using the context ID in this indication. The context of a Geofence may contain Wi-Fi area ID lists, IBeacon lists,
+  Cell-ID list, and so forth.    */
+#define QMI_LOC_EVENT_MASK_GDT_UPLOAD_BEGIN_REQ_V02 ((qmiLocEventRegMaskT_v02)0x08000000ull) /**<  The control point must enable this mask to receive Generic Data Transport (GDT)
+        upload session begin request event indications.  */
+#define QMI_LOC_EVENT_MASK_GDT_UPLOAD_END_REQ_V02 ((qmiLocEventRegMaskT_v02)0x10000000ull) /**<  The control point must enable this mask to receive GDT
+        upload session end request event indications.  */
+#define QMI_LOC_EVENT_MASK_GEOFENCE_BATCH_DWELL_NOTIFICATION_V02 ((qmiLocEventRegMaskT_v02)0x20000000ull) /**<  The control point must enable this mask to receive notifications when
+       a Geofence is dwelled. These events are generated when a UE enters
+       or leaves the perimeter of a Geofence and dwells inside or outside for a specified time.
+       This dwell notification is for multiple Geofences. Dwells from multiple Geofences are all batched and
+       sent in the same notification.  */
+#define QMI_LOC_EVENT_MASK_GET_TIME_ZONE_REQ_V02 ((qmiLocEventRegMaskT_v02)0x40000000ull) /**<  The control point must enable this mask to receive requests for time zone information from
+       the service. These events are generated when there is a need for time zone information in the
+       service.  */
+#define QMI_LOC_EVENT_MASK_BATCHING_STATUS_V02 ((qmiLocEventRegMaskT_v02)0x80000000ull) /**<  The control point must enable this mask to receive asynchronous events related
+       to batching.  */
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to register for events from the
+                    location subsystem. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Event Registration Mask */
+  qmiLocEventRegMaskT_v02 eventRegMask;
+  /**<   Specifies the events that the control point is interested in receiving.
+ Valid bitmasks:
+      - QMI_LOC_EVENT_MASK_POSITION_REPORT (0x00000001) --  The control point must enable this mask to receive position report
+       event indications.
+      - QMI_LOC_EVENT_MASK_GNSS_SV_INFO (0x00000002) --  The control point must enable this mask to receive satellite report
+       event indications. These reports are sent at a 1 Hz rate.
+      - QMI_LOC_EVENT_MASK_NMEA (0x00000004) --  The control point must enable this mask to receive NMEA reports for
+       position and satellites in view. The report is at a 1 Hz rate.
+      - QMI_LOC_EVENT_MASK_NI_NOTIFY_VERIFY_REQ (0x00000008) --  The control point must enable this mask to receive NI Notify/Verify request
+       event indications.
+      - QMI_LOC_EVENT_MASK_INJECT_TIME_REQ (0x00000010) --  The control point must enable this mask to receive time injection request
+       event indications.
+      - QMI_LOC_EVENT_MASK_INJECT_PREDICTED_ORBITS_REQ (0x00000020) --  The control point must enable this mask to receive predicted orbits request
+       event indications.
+      - QMI_LOC_EVENT_MASK_INJECT_POSITION_REQ (0x00000040) --  The control point must enable this mask to receive position injection request
+       event indications.
+      - QMI_LOC_EVENT_MASK_ENGINE_STATE (0x00000080) --  The control point must enable this mask to receive engine state report
+       event indications.
+      - QMI_LOC_EVENT_MASK_FIX_SESSION_STATE (0x00000100) --  The control point must enable this mask to receive fix session status report
+       event indications.
+      - QMI_LOC_EVENT_MASK_WIFI_REQ (0x00000200) --  The control point must enable this mask to receive Wi-Fi position request
+       event indications.
+      - QMI_LOC_EVENT_MASK_SENSOR_STREAMING_READY_STATUS (0x00000400) --  The control point must enable this mask to receive notifications from the
+       location engine indicating its readiness to accept data from the
+       sensors (accelerometer, gyroscope, etc.).
+      - QMI_LOC_EVENT_MASK_TIME_SYNC_REQ (0x00000800) --  The control point must enable this mask to receive time sync requests
+       from the GPS engine. Time sync enables the GPS engine to synchronize
+       its clock with the sensor processor's clock.
+      - QMI_LOC_EVENT_MASK_SET_SPI_STREAMING_REPORT (0x00001000) --  The control point must enable this mask to receive Stationary Position
+       Indicator (SPI) streaming report indications.
+      - QMI_LOC_EVENT_MASK_LOCATION_SERVER_CONNECTION_REQ (0x00002000) --  The control point must enable this mask to receive location server
+       requests. These requests are generated when the service wishes to
+       establish a connection with a location server.
+      - QMI_LOC_EVENT_MASK_NI_GEOFENCE_NOTIFICATION (0x00004000) --  The control point must enable this mask to receive notifications
+       related to network-initiated Geofences. These events notify the client
+       when a network-initiated Geofence is added, deleted, or edited.
+      - QMI_LOC_EVENT_MASK_GEOFENCE_GEN_ALERT (0x00008000) --  The control point must enable this mask to receive Geofence alerts.
+       These alerts are generated to inform the client of the changes that may
+       affect a Geofence, e.g., if GPS is turned off or if the network is
+       unavailable.
+      - QMI_LOC_EVENT_MASK_GEOFENCE_BREACH_NOTIFICATION (0x00010000) --  The control point must enable this mask to receive notifications when
+       a Geofence is breached. These events are generated when a UE enters
+       or leaves the perimeter of a Geofence. This breach report is for a single
+       Geofence .
+      - QMI_LOC_EVENT_MASK_PEDOMETER_CONTROL (0x00020000) --  The control point must enable this mask to register for pedometer
+       control requests from the location engine. The location engine sends
+       this event to control the injection of pedometer reports.
+      - QMI_LOC_EVENT_MASK_MOTION_DATA_CONTROL (0x00040000) --  The control point must enable this mask to register for motion data
+       control requests from the location engine. The location engine sends
+       this event to control the injection of motion data.
+      - QMI_LOC_EVENT_MASK_BATCH_FULL_NOTIFICATION (0x00080000) --  The control point must enable this mask to receive notification when
+       a batch is full. The location engine sends this event to notify of Batch Full
+       for ongoing batching session.
+      - QMI_LOC_EVENT_MASK_LIVE_BATCHED_POSITION_REPORT (0x00100000) --  The control point must enable this mask to receive position report
+       indications along with an ongoing batching session. The location engine sends
+       this event to notify the batched position report while a batching session
+       is ongoing.
+      - QMI_LOC_EVENT_MASK_INJECT_WIFI_AP_DATA_REQ (0x00200000) --  The control point must enable this mask to receive Wi-Fi AP data inject request
+       event indications.
+      - QMI_LOC_EVENT_MASK_GEOFENCE_BATCH_BREACH_NOTIFICATION (0x00400000) --  The control point must enable this mask to receive notifications when
+       a Geofence is breached. These events are generated when a UE enters
+       or leaves the perimeter of a Geofence. This breach notification is for
+       multiple Geofences. Breaches from multiple Geofences are all batched and
+       sent in the same notification .
+      - QMI_LOC_EVENT_MASK_VEHICLE_DATA_READY_STATUS (0x00800000) --  The control point must enable this mask to receive notifications from the
+       location engine indicating its readiness to accept vehicle data (vehicle
+       accelerometer, vehicle angular rate, vehicle odometry, etc.).
+      - QMI_LOC_EVENT_MASK_GNSS_MEASUREMENT_REPORT (0x01000000) --  The control point must enable this mask to receive system clock and satellite
+       measurement report events (system clock, SV time, Doppler, etc.). Reports are
+       generated only for the GNSS satellite constellations that are enabled using
+       QMI_LOC_SET_GNSS_CONSTELL_REPORT_CONFIG.
+      - QMI_LOC_EVENT_MASK_GNSS_SV_POLYNOMIAL_REPORT (0x02000000) --  The control point must enable this mask to receive satellite position
+        reports as polynomials. Reports are generated only for the GNSS satellite
+        constellations that are enabled using QMI_LOC_SET_GNSS_CONSTELL_REPORT_CONFIG.
+      - QMI_LOC_EVENT_MASK_GEOFENCE_PROXIMITY_NOTIFICATION (0x04000000) --  The control point must enable this mask to receive notifications when a Geofence proximity is entered
+  and exited. The proximity of a Geofence may be due to different contexts. These contexts are identified
+  using the context ID in this indication. The context of a Geofence may contain Wi-Fi area ID lists, IBeacon lists,
+  Cell-ID list, and so forth.
+      - QMI_LOC_EVENT_MASK_GDT_UPLOAD_BEGIN_REQ (0x08000000) --  The control point must enable this mask to receive Generic Data Transport (GDT)
+        upload session begin request event indications.
+      - QMI_LOC_EVENT_MASK_GDT_UPLOAD_END_REQ (0x10000000) --  The control point must enable this mask to receive GDT
+        upload session end request event indications.
+      - QMI_LOC_EVENT_MASK_GEOFENCE_BATCH_DWELL_NOTIFICATION (0x20000000) --  The control point must enable this mask to receive notifications when
+       a Geofence is dwelled. These events are generated when a UE enters
+       or leaves the perimeter of a Geofence and dwells inside or outside for a specified time.
+       This dwell notification is for multiple Geofences. Dwells from multiple Geofences are all batched and
+       sent in the same notification.
+      - QMI_LOC_EVENT_MASK_GET_TIME_ZONE_REQ (0x40000000) --  The control point must enable this mask to receive requests for time zone information from
+       the service. These events are generated when there is a need for time zone information in the
+       service.
+      - QMI_LOC_EVENT_MASK_BATCHING_STATUS (0x80000000) --  The control point must enable this mask to receive asynchronous events related
+       to batching.
+
+ Multiple events can be registered by ORing the individual masks and
+ sending them in this TLV. All unused bits in this mask must be set to 0.
+ */
+}qmiLocRegEventsReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCFIXRECURRENCEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_RECURRENCE_PERIODIC_V02 = 1, /**<  Request periodic position fixes  */
+  eQMI_LOC_RECURRENCE_SINGLE_V02 = 2, /**<  Request a single position fix  */
+  QMILOCFIXRECURRENCEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocFixRecurrenceEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCACCURACYLEVELENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_ACCURACY_LOW_V02 = 1, /**<  Low accuracy  */
+  eQMI_LOC_ACCURACY_MED_V02 = 2, /**<  Medium accuracy  */
+  eQMI_LOC_ACCURACY_HIGH_V02 = 3, /**<  High accuracy  */
+  QMILOCACCURACYLEVELENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocAccuracyLevelEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCINTERMEDIATEREPORTSTATEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_INTERMEDIATE_REPORTS_ON_V02 = 1, /**<  Intermediate reports are turned on  */
+  eQMI_LOC_INTERMEDIATE_REPORTS_OFF_V02 = 2, /**<  Intermediate reports are turned off  */
+  QMILOCINTERMEDIATEREPORTSTATEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocIntermediateReportStateEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCCONFIGINCLUDEALTITUDEASSUMEDINGNSSSVINFOENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_ALTITUDE_ASSUMED_IN_GNSS_SV_INFO_ENABLED_V02 = 1, /**<  Enable Altitude Assumed information in GNSS SV Info Event.  */
+  eQMI_LOC_ALTITUDE_ASSUMED_IN_GNSS_SV_INFO_DISABLED_V02 = 2, /**<  Disable Altitude Assumed information in GNSS SV Info Event.  */
+  QMILOCCONFIGINCLUDEALTITUDEASSUMEDINGNSSSVINFOENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocConfigIncludeAltitudeAssumedInGnssSvInfoEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  char applicationProvider[QMI_LOC_MAX_APP_ID_PROVIDER_LENGTH_V02 + 1];
+  /**<   Application provider. */
+
+  char applicationName[QMI_LOC_MAX_APP_ID_NAME_LENGTH_V02 + 1];
+  /**<   Application name. */
+
+  uint8_t applicationVersion_valid;
+  /**<   Specifies whether the application version string contains
+        a valid value: \begin{itemize1}
+       \item    0x00 (FALSE) -- Application version string is invalid
+       \item    0x01 (TRUE) -- Application version string is valid
+       \vspace{-0.18in} \end{itemize1} */
+
+  char applicationVersion[QMI_LOC_MAX_APP_ID_VERSION_LENGTH_V02 + 1];
+  /**<   Application version. */
+}qmiLocApplicationIdStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to initiate a GPS session. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Session ID */
+  uint8_t sessionId;
+  /**<   ID of the session as identified by the control point. The session ID
+       is reported back in the position reports. The control point must
+       specify the same session ID in the QMI_LOC_STOP_REQ message. \n
+       - Range: 0 to 255
+  */
+
+  /* Optional */
+  /*  Recurrence Type */
+  uint8_t fixRecurrence_valid;  /**< Must be set to true if fixRecurrence is being passed */
+  qmiLocFixRecurrenceEnumT_v02 fixRecurrence;
+  /**<   Specifies the type of session in which the control point is interested.
+ If this TLV is not specified, recurrence defaults to SINGLE.
+
+ Valid values: \n
+      - eQMI_LOC_RECURRENCE_PERIODIC (1) --  Request periodic position fixes
+      - eQMI_LOC_RECURRENCE_SINGLE (2) --  Request a single position fix
+ */
+
+  /* Optional */
+  /*  Horizontal Accuracy */
+  uint8_t horizontalAccuracyLevel_valid;  /**< Must be set to true if horizontalAccuracyLevel is being passed */
+  qmiLocAccuracyLevelEnumT_v02 horizontalAccuracyLevel;
+  /**<   Specifies the horizontal accuracy level required by the control point.
+ If not specified, accuracy defaults to LOW.
+
+ Valid values: \n
+      - eQMI_LOC_ACCURACY_LOW (1) --  Low accuracy
+      - eQMI_LOC_ACCURACY_MED (2) --  Medium accuracy
+      - eQMI_LOC_ACCURACY_HIGH (3) --  High accuracy
+ */
+
+  /* Optional */
+  /*  Enable/Disable Intermediate Reports */
+  uint8_t intermediateReportState_valid;  /**< Must be set to true if intermediateReportState is being passed */
+  qmiLocIntermediateReportStateEnumT_v02 intermediateReportState;
+  /**<   Specifies if the control point is interested in receiving intermediate
+ reports. The control point must explicitly set this field to OFF if it
+ does not wish to receive intermediate position reports. Intermediate
+ position reports are generated at 1 Hz and are ON by default. If
+ intermediate reports are turned ON, the client receives position reports
+ even if the accuracy criteria are not met. The status in such a position
+ report is set to IN_PROGRESS in order for the control point to identify
+ intermediate reports.
+
+ Valid values: \n
+      - eQMI_LOC_INTERMEDIATE_REPORTS_ON (1) --  Intermediate reports are turned on
+      - eQMI_LOC_INTERMEDIATE_REPORTS_OFF (2) --  Intermediate reports are turned off
+ */
+
+  /* Optional */
+  /*  Minimum Interval Between Final Position Reports */
+  uint8_t minInterval_valid;  /**< Must be set to true if minInterval is being passed */
+  uint32_t minInterval;
+  /**<   Minimum time interval, specified by the control point, that must elapse between
+       final position reports. \n
+       - Units: Milliseconds \n
+       - Default: 1000 ms
+  */
+
+  /* Optional */
+  /*  ID of the Application that Sent this Request */
+  uint8_t applicationId_valid;  /**< Must be set to true if applicationId is being passed */
+  qmiLocApplicationIdStructT_v02 applicationId;
+  /**<   \n Application provider, name, and version.*/
+
+  /* Optional */
+  /*  Configuration for Altitude Assumed Info in GNSS SV Info Event */
+  uint8_t configAltitudeAssumed_valid;  /**< Must be set to true if configAltitudeAssumed is being passed */
+  qmiLocConfigIncludeAltitudeAssumedInGnssSvInfoEnumT_v02 configAltitudeAssumed;
+  /**<   Specifies the configuration to include Altitude Assumed information in the GNSS SV Info Event.
+ When enabled, an additional GNSS SV Info event indication is sent to the control
+ point that also includes the altitude assumed information.
+
+ If not specified, the configuration defaults to ENABLED.
+
+ Valid values: \n
+      - eQMI_LOC_ALTITUDE_ASSUMED_IN_GNSS_SV_INFO_ENABLED (1) --  Enable Altitude Assumed information in GNSS SV Info Event.
+      - eQMI_LOC_ALTITUDE_ASSUMED_IN_GNSS_SV_INFO_DISABLED (2) --  Disable Altitude Assumed information in GNSS SV Info Event.
+ */
+
+  /* Optional */
+  /*  Minimum Interval Between Intermediate Position Reports */
+  uint8_t minIntermediatePositionReportInterval_valid;  /**< Must be set to true if minIntermediatePositionReportInterval is being passed */
+  uint32_t minIntermediatePositionReportInterval;
+  /**<   Minimum time interval for intermediate position reports, specified by the control point,
+       that, between the position reports elapsed time, must be longer than the interval time.
+       If this optional value is not set or set to the default value (0), the intermediate position
+       will be reported when it is ready. \n
+       - Units: Milliseconds \n
+       - Default: 0 ms
+  */
+
+  /* Optional */
+  /*  Maximum Wait Time to Get a Position Report */
+  uint8_t positionReportTimeout_valid;  /**< Must be set to true if positionReportTimeout is being passed */
+  uint32_t positionReportTimeout;
+  /**<   Maximum time to work on each fix, specified by the control point.
+       The GPS engine returns QMI_ERR_INTERNAL if a position cannot be obtained
+       within the positionReportTimeout value. \n
+       - Units: Milliseconds \n
+       - Default: 255*1000 ms \n
+       - Range: 1000 - 255*1000 ms
+  */
+
+  /* Optional */
+  /*  Share position report with other clients */
+  uint8_t sharePosition_valid;  /**< Must be set to true if sharePosition is being passed */
+  uint8_t sharePosition;
+  /**<   Allow to share the position report with the other QMI_LOC clients \n
+         \item    0x00(FALSE) Do not share the position report
+         \item    0x01(TRUE)  Share the position report
+    If this optional TLV is not set, the GPS engine allows the position sharing.
+        \vspace{-0.18in} \end{itemize1}
+  */
+}qmiLocStartReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to stop a GPS session. */
+typedef struct {
+
+  /* Mandatory */
+  /*   Session ID */
+  uint8_t sessionId;
+  /**<   ID of the session that was specified in the Start request
+       (QMI_LOC_START_REQ).\n
+       - Range: 0 to 255 */
+}qmiLocStopReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+typedef uint32_t qmiLocPosTechMaskT_v02;
+#define QMI_LOC_POS_TECH_MASK_SATELLITE_V02 ((qmiLocPosTechMaskT_v02)0x00000001) /**<  Satellites were used to generate the fix  */
+#define QMI_LOC_POS_TECH_MASK_CELLID_V02 ((qmiLocPosTechMaskT_v02)0x00000002) /**<  Cell towers were used to generate the fix  */
+#define QMI_LOC_POS_TECH_MASK_WIFI_V02 ((qmiLocPosTechMaskT_v02)0x00000004) /**<  Wi-Fi access points were used to generate the fix  */
+#define QMI_LOC_POS_TECH_MASK_SENSORS_V02 ((qmiLocPosTechMaskT_v02)0x00000008) /**<  Sensors were used to generate the fix  */
+#define QMI_LOC_POS_TECH_MASK_REFERENCE_LOCATION_V02 ((qmiLocPosTechMaskT_v02)0x00000010) /**<  Reference Location was used to generate the fix  */
+#define QMI_LOC_POS_TECH_MASK_INJECTED_COARSE_POSITION_V02 ((qmiLocPosTechMaskT_v02)0x00000020) /**<  Coarse position injected into the location engine was used to
+        generate the fix  */
+#define QMI_LOC_POS_TECH_MASK_AFLT_V02 ((qmiLocPosTechMaskT_v02)0x00000040) /**<  AFLT was used to generate the fix  */
+#define QMI_LOC_POS_TECH_MASK_HYBRID_V02 ((qmiLocPosTechMaskT_v02)0x00000080) /**<  GNSS and network-provided measurements were used to
+        generate the fix  */
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCSESSIONSTATUSENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_SESS_STATUS_SUCCESS_V02 = 0, /**<  Session was successful  */
+  eQMI_LOC_SESS_STATUS_IN_PROGRESS_V02 = 1, /**<  Session is still in progress; further position reports will be generated
+       until either the fix criteria specified by the client are met or the
+       client response timeout occurs  */
+  eQMI_LOC_SESS_STATUS_GENERAL_FAILURE_V02 = 2, /**<  Session failed  */
+  eQMI_LOC_SESS_STATUS_TIMEOUT_V02 = 3, /**<  Fix request failed because the session timed out  */
+  eQMI_LOC_SESS_STATUS_USER_END_V02 = 4, /**<  Fix request failed because the session was ended by the user  */
+  eQMI_LOC_SESS_STATUS_BAD_PARAMETER_V02 = 5, /**<  Fix request failed due to bad parameters in the request  */
+  eQMI_LOC_SESS_STATUS_PHONE_OFFLINE_V02 = 6, /**<  Fix request failed because the phone is offline  */
+  eQMI_LOC_SESS_STATUS_ENGINE_LOCKED_V02 = 7, /**<  Fix request failed because the engine is locked  */
+  QMILOCSESSIONSTATUSENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocSessionStatusEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint16_t gpsWeek;
+  /**<   Current GPS week as calculated from midnight, Jan. 6, 1980. \n
+       - Units: Weeks */
+
+  uint32_t gpsTimeOfWeekMs;
+  /**<   Amount of time into the current GPS week. \n
+       - Units: Milliseconds */
+}qmiLocGPSTimeStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  float PDOP;
+  /**<   Position dilution of precision.
+       \begin{itemize1}
+       \item    Range: 1 (highest accuracy) to 50 (lowest accuracy)
+       \item    PDOP = square root of (HDOP^2 + VDOP^2)
+       \vspace{-0.18in} \end{itemize1} */
+
+  float HDOP;
+  /**<   Horizontal dilution of precision.
+       \begin{itemize1}
+       \item    Range: 1 (highest accuracy) to 50 (lowest accuracy)
+       \vspace{-0.18in} \end{itemize1} */
+
+  float VDOP;
+  /**<   Vertical dilution of precision.
+       \begin{itemize1}
+       \item    Range: 1 (highest accuracy) to 50 (lowest accuracy)
+       \vspace{-0.18in} \end{itemize1} */
+}qmiLocDOPStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+typedef uint32_t qmiLocSensorUsageMaskT_v02;
+#define QMI_LOC_SENSOR_MASK_USED_ACCEL_V02 ((qmiLocSensorUsageMaskT_v02)0x00000001) /**<  Bitmask to specify whether an accelerometer was used.  */
+#define QMI_LOC_SENSOR_MASK_USED_GYRO_V02 ((qmiLocSensorUsageMaskT_v02)0x00000002) /**<  Bitmask to specify whether a gyroscope was used.  */
+typedef uint32_t qmiLocSensorAidedMaskT_v02;
+#define QMI_LOC_SENSOR_AIDED_MASK_HEADING_V02 ((qmiLocSensorAidedMaskT_v02)0x00000001) /**<  Bitmask to specify whether a sensor was used to calculate heading.  */
+#define QMI_LOC_SENSOR_AIDED_MASK_SPEED_V02 ((qmiLocSensorAidedMaskT_v02)0x00000002) /**<  Bitmask to specify whether a sensor was used to calculate speed.  */
+#define QMI_LOC_SENSOR_AIDED_MASK_POSITION_V02 ((qmiLocSensorAidedMaskT_v02)0x00000004) /**<  Bitmask to specify whether a sensor was used to calculate position.  */
+#define QMI_LOC_SENSOR_AIDED_MASK_VELOCITY_V02 ((qmiLocSensorAidedMaskT_v02)0x00000008) /**<  Bitmask to specify whether a sensor was used to calculate velocity.  */
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  qmiLocSensorUsageMaskT_v02 usageMask;
+  /**<   Specifies which sensors were used in calculating the position in the
+       position report.
+
+       Valid bitmasks: \begin{itemize1}
+       \item    0x00000001 -- SENSOR_USED_ ACCEL
+       \item    0x00000002 -- SENSOR_USED_ GYRO
+       \vspace{-0.18in} \end{itemize1} */
+
+  qmiLocSensorAidedMaskT_v02 aidingIndicatorMask;
+  /**<   Specifies which results were aided by sensors.
+
+       Valid bitmasks: \n
+         - 0x00000001 -- AIDED_HEADING \n
+         - 0x00000002 -- AIDED_SPEED \n
+         - 0x00000004 -- AIDED_POSITION \n
+         - 0x00000008 -- AIDED_VELOCITY */
+}qmiLocSensorUsageIndicatorStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCTIMESOURCEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_TIME_SRC_INVALID_V02 = 0, /**<  Invalid time.  */
+  eQMI_LOC_TIME_SRC_NETWORK_TIME_TRANSFER_V02 = 1, /**<  Time is set by the 1X system  */
+  eQMI_LOC_TIME_SRC_NETWORK_TIME_TAGGING_V02 = 2, /**<  Time is set by WCDMA/GSM time tagging (that is,
+       associating network time with GPS time)  */
+  eQMI_LOC_TIME_SRC_EXTERNAL_INPUT_V02 = 3, /**<  Time is set by an external injection  */
+  eQMI_LOC_TIME_SRC_TOW_DECODE_V02 = 4, /**<  Time is set after decoding over-the-air GPS navigation data
+       from one GPS satellite  */
+  eQMI_LOC_TIME_SRC_TOW_CONFIRMED_V02 = 5, /**<  Time is set after decoding over-the-air GPS navigation data
+       from multiple satellites  */
+  eQMI_LOC_TIME_SRC_TOW_AND_WEEK_CONFIRMED_V02 = 6, /**<  Both time of the week and the GPS week number are known  */
+  eQMI_LOC_TIME_SRC_NAV_SOLUTION_V02 = 7, /**<  Time is set by the position engine after the fix is obtained  */
+  eQMI_LOC_TIME_SRC_SOLVE_FOR_TIME_V02 = 8, /**<  Time is set by the position engine after performing SFT;
+       this is done when the clock time uncertainty is large  */
+  eQMI_LOC_TIME_SRC_GLO_TOW_DECODE_V02 = 9, /**<  Time is set after decoding GLO satellites  */
+  eQMI_LOC_TIME_SRC_TIME_TRANSFORM_V02 = 10, /**<  Time is set after transforming the GPS to GLO time  */
+  eQMI_LOC_TIME_SRC_WCDMA_SLEEP_TIME_TAGGING_V02 = 11, /**<  Time is set by the sleep time tag provided by the WCDMA network  */
+  eQMI_LOC_TIME_SRC_GSM_SLEEP_TIME_TAGGING_V02 = 12, /**<  Time is set by the sleep time tag provided by the GSM network  */
+  eQMI_LOC_TIME_SRC_UNKNOWN_V02 = 13, /**<  Source of the time is unknown  */
+  eQMI_LOC_TIME_SRC_SYSTEM_TIMETICK_V02 = 14, /**<  Time is derived from the system clock (better known as the slow clock);
+       GNSS time is maintained irrespective of the GNSS receiver state  */
+  eQMI_LOC_TIME_SRC_QZSS_TOW_DECODE_V02 = 15, /**<  Time is set after decoding QZSS satellites  */
+  eQMI_LOC_TIME_SRC_BDS_TOW_DECODE_V02 = 16, /**<  Time is set after decoding BDS satellites  */
+  eQMI_LOC_TIME_SRC_GAL_TOW_DECODE_V02 = 17, /**<  Time is set after decoding GAL satellites  */
+  QMILOCTIMESOURCEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocTimeSourceEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCRELIABILITYENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_RELIABILITY_NOT_SET_V02 = 0, /**<  Location reliability is not set  */
+  eQMI_LOC_RELIABILITY_VERY_LOW_V02 = 1, /**<  Location reliability is very low; use it at your own risk  */
+  eQMI_LOC_RELIABILITY_LOW_V02 = 2, /**<  Location reliability is low; little or no cross-checking is possible  */
+  eQMI_LOC_RELIABILITY_MEDIUM_V02 = 3, /**<  Location reliability is medium; limited cross-check passed   */
+  eQMI_LOC_RELIABILITY_HIGH_V02 = 4, /**<  Location reliability is high; strong cross-check passed  */
+  QMILOCRELIABILITYENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocReliabilityEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Sends the position report to the control point. */
+typedef struct {
+
+  /* Mandatory */
+  /*   Session Status */
+  qmiLocSessionStatusEnumT_v02 sessionStatus;
+  /**<   Session status.
+
+ Valid values: \n
+      - eQMI_LOC_SESS_STATUS_SUCCESS (0) --  Session was successful
+      - eQMI_LOC_SESS_STATUS_IN_PROGRESS (1) --  Session is still in progress; further position reports will be generated
+       until either the fix criteria specified by the client are met or the
+       client response timeout occurs
+      - eQMI_LOC_SESS_STATUS_GENERAL_FAILURE (2) --  Session failed
+      - eQMI_LOC_SESS_STATUS_TIMEOUT (3) --  Fix request failed because the session timed out
+      - eQMI_LOC_SESS_STATUS_USER_END (4) --  Fix request failed because the session was ended by the user
+      - eQMI_LOC_SESS_STATUS_BAD_PARAMETER (5) --  Fix request failed due to bad parameters in the request
+      - eQMI_LOC_SESS_STATUS_PHONE_OFFLINE (6) --  Fix request failed because the phone is offline
+      - eQMI_LOC_SESS_STATUS_ENGINE_LOCKED (7) --  Fix request failed because the engine is locked
+ */
+
+  /* Mandatory */
+  /*   Session ID */
+  uint8_t sessionId;
+  /**<    ID of the session that was specified in the Start request
+        QMI_LOC_START_REQ. \n
+        - Range: 0 to 255 */
+
+  /* Optional */
+  /*  Latitude */
+  uint8_t latitude_valid;  /**< Must be set to true if latitude is being passed */
+  double latitude;
+  /**<   Latitude (specified in WGS84 datum).
+       \begin{itemize1}
+       \item    Type: Floating point
+       \item    Units: Degrees
+       \item    Range: -90.0 to 90.0   \begin{itemize1}
+         \item    Positive values indicate northern latitude
+         \item    Negative values indicate southern latitude
+       \vspace{-0.18in} \end{itemize1} \end{itemize1} */
+
+  /* Optional */
+  /*   Longitude */
+  uint8_t longitude_valid;  /**< Must be set to true if longitude is being passed */
+  double longitude;
+  /**<   Longitude (specified in WGS84 datum).
+       \begin{itemize1}
+       \item    Type: Floating point
+       \item    Units: Degrees
+       \item    Range: -180.0 to 180.0   \begin{itemize1}
+         \item    Positive values indicate eastern longitude
+         \item    Negative values indicate western longitude
+       \vspace{-0.18in} \end{itemize1} \end{itemize1} */
+
+  /* Optional */
+  /*   Circular Horizontal Position Uncertainty */
+  uint8_t horUncCircular_valid;  /**< Must be set to true if horUncCircular is being passed */
+  float horUncCircular;
+  /**<   Horizontal position uncertainty (circular).\n
+       - Units: Meters */
+
+  /* Optional */
+  /*  Horizontal Elliptical Uncertainty (Semi-Minor Axis) */
+  uint8_t horUncEllipseSemiMinor_valid;  /**< Must be set to true if horUncEllipseSemiMinor is being passed */
+  float horUncEllipseSemiMinor;
+  /**<   Semi-minor axis of horizontal elliptical uncertainty.\n
+       - Units: Meters */
+
+  /* Optional */
+  /*  Horizontal Elliptical Uncertainty (Semi-Major Axis) */
+  uint8_t horUncEllipseSemiMajor_valid;  /**< Must be set to true if horUncEllipseSemiMajor is being passed */
+  float horUncEllipseSemiMajor;
+  /**<   Semi-major axis of horizontal elliptical uncertainty.\n
+       - Units: Meters */
+
+  /* Optional */
+  /*  Elliptical Horizontal Uncertainty Azimuth */
+  uint8_t horUncEllipseOrientAzimuth_valid;  /**< Must be set to true if horUncEllipseOrientAzimuth is being passed */
+  float horUncEllipseOrientAzimuth;
+  /**<   Elliptical horizontal uncertainty azimuth of orientation.\n
+       - Units: Decimal degrees \n
+       - Range: 0 to 180 */
+
+  /* Optional */
+  /*  Horizontal Confidence */
+  uint8_t horConfidence_valid;  /**< Must be set to true if horConfidence is being passed */
+  uint8_t horConfidence;
+  /**<   Horizontal uncertainty confidence.
+       If both elliptical and horizontal uncertainties are specified in this message,
+       the confidence corresponds to the elliptical uncertainty. \n
+       - Units: Percent \n
+       - Range: 0 to 99 */
+
+  /* Optional */
+  /*  Horizontal Reliability */
+  uint8_t horReliability_valid;  /**< Must be set to true if horReliability is being passed */
+  qmiLocReliabilityEnumT_v02 horReliability;
+  /**<   Specifies the reliability of the horizontal position.
+ Valid values: \n
+      - eQMI_LOC_RELIABILITY_NOT_SET (0) --  Location reliability is not set
+      - eQMI_LOC_RELIABILITY_VERY_LOW (1) --  Location reliability is very low; use it at your own risk
+      - eQMI_LOC_RELIABILITY_LOW (2) --  Location reliability is low; little or no cross-checking is possible
+      - eQMI_LOC_RELIABILITY_MEDIUM (3) --  Location reliability is medium; limited cross-check passed
+      - eQMI_LOC_RELIABILITY_HIGH (4) --  Location reliability is high; strong cross-check passed
+ */
+
+  /* Optional */
+  /*  Horizontal Speed */
+  uint8_t speedHorizontal_valid;  /**< Must be set to true if speedHorizontal is being passed */
+  float speedHorizontal;
+  /**<   Horizontal speed.\n
+       - Units: Meters/second */
+
+  /* Optional */
+  /*  Speed Uncertainty */
+  uint8_t speedUnc_valid;  /**< Must be set to true if speedUnc is being passed */
+  float speedUnc;
+  /**<   3-D Speed uncertainty.\n
+       - Units: Meters/second */
+
+  /* Optional */
+  /*  Altitude With Respect to Ellipsoid */
+  uint8_t altitudeWrtEllipsoid_valid;  /**< Must be set to true if altitudeWrtEllipsoid is being passed */
+  float altitudeWrtEllipsoid;
+  /**<   Altitude with respect to the WGS84 ellipsoid.\n
+       - Units: Meters \n
+       - Range: -500 to 15883 */
+
+  /* Optional */
+  /*  Altitude With Respect to Sea Level */
+  uint8_t altitudeWrtMeanSeaLevel_valid;  /**< Must be set to true if altitudeWrtMeanSeaLevel is being passed */
+  float altitudeWrtMeanSeaLevel;
+  /**<   Altitude with respect to mean sea level.\n
+       - Units: Meters */
+
+  /* Optional */
+  /*  Vertical Uncertainty */
+  uint8_t vertUnc_valid;  /**< Must be set to true if vertUnc is being passed */
+  float vertUnc;
+  /**<   Vertical uncertainty.\n
+       - Units: Meters */
+
+  /* Optional */
+  /*  Vertical Confidence */
+  uint8_t vertConfidence_valid;  /**< Must be set to true if vertConfidence is being passed */
+  uint8_t vertConfidence;
+  /**<   Vertical uncertainty confidence.\n
+       - Units: Percent \n
+       - Range: 0 to 99 */
+
+  /* Optional */
+  /*  Vertical Reliability */
+  uint8_t vertReliability_valid;  /**< Must be set to true if vertReliability is being passed */
+  qmiLocReliabilityEnumT_v02 vertReliability;
+  /**<   Specifies the reliability of the vertical position.
+ Valid values: \n
+      - eQMI_LOC_RELIABILITY_NOT_SET (0) --  Location reliability is not set
+      - eQMI_LOC_RELIABILITY_VERY_LOW (1) --  Location reliability is very low; use it at your own risk
+      - eQMI_LOC_RELIABILITY_LOW (2) --  Location reliability is low; little or no cross-checking is possible
+      - eQMI_LOC_RELIABILITY_MEDIUM (3) --  Location reliability is medium; limited cross-check passed
+      - eQMI_LOC_RELIABILITY_HIGH (4) --  Location reliability is high; strong cross-check passed
+ */
+
+  /* Optional */
+  /*  Vertical Speed */
+  uint8_t speedVertical_valid;  /**< Must be set to true if speedVertical is being passed */
+  float speedVertical;
+  /**<   Vertical speed.\n
+         - Units: Meters/second */
+
+  /* Optional */
+  /*  Heading */
+  uint8_t heading_valid;  /**< Must be set to true if heading is being passed */
+  float heading;
+  /**<   Heading.\n
+         - Units: Degrees \n
+         - Range: 0 to 359.999  */
+
+  /* Optional */
+  /*  Heading Uncertainty */
+  uint8_t headingUnc_valid;  /**< Must be set to true if headingUnc is being passed */
+  float headingUnc;
+  /**<   Heading uncertainty.\n
+       - Units: Degrees \n
+       - Range: 0 to 359.999 */
+
+  /* Optional */
+  /*  Magnetic Deviation */
+  uint8_t magneticDeviation_valid;  /**< Must be set to true if magneticDeviation is being passed */
+  float magneticDeviation;
+  /**<   Difference between the bearing to true north and the bearing shown
+      on a magnetic compass. The deviation is positive when the magnetic
+      north is east of true north. */
+
+  /* Optional */
+  /*  Technology Used */
+  uint8_t technologyMask_valid;  /**< Must be set to true if technologyMask is being passed */
+  qmiLocPosTechMaskT_v02 technologyMask;
+  /**<   Technology used in computing this fix.
+ Valid bitmasks: \n
+      - QMI_LOC_POS_TECH_MASK_SATELLITE (0x00000001) --  Satellites were used to generate the fix
+      - QMI_LOC_POS_TECH_MASK_CELLID (0x00000002) --  Cell towers were used to generate the fix
+      - QMI_LOC_POS_TECH_MASK_WIFI (0x00000004) --  Wi-Fi access points were used to generate the fix
+      - QMI_LOC_POS_TECH_MASK_SENSORS (0x00000008) --  Sensors were used to generate the fix
+      - QMI_LOC_POS_TECH_MASK_REFERENCE_LOCATION (0x00000010) --  Reference Location was used to generate the fix
+      - QMI_LOC_POS_TECH_MASK_INJECTED_COARSE_POSITION (0x00000020) --  Coarse position injected into the location engine was used to
+        generate the fix
+      - QMI_LOC_POS_TECH_MASK_AFLT (0x00000040) --  AFLT was used to generate the fix
+      - QMI_LOC_POS_TECH_MASK_HYBRID (0x00000080) --  GNSS and network-provided measurements were used to
+        generate the fix
+ */
+
+  /* Optional */
+  /*  Dilution of Precision */
+  uint8_t DOP_valid;  /**< Must be set to true if DOP is being passed */
+  qmiLocDOPStructT_v02 DOP;
+  /**<   \vspace{0.06in} \n Dilution of precision associated with this position. */
+
+  /* Optional */
+  /*  UTC Timestamp */
+  uint8_t timestampUtc_valid;  /**< Must be set to true if timestampUtc is being passed */
+  uint64_t timestampUtc;
+  /**<   UTC timestamp. \n
+       - Units: Milliseconds since Jan. 1, 1970 */
+
+  /* Optional */
+  /*  Leap Seconds */
+  uint8_t leapSeconds_valid;  /**< Must be set to true if leapSeconds is being passed */
+  uint8_t leapSeconds;
+  /**<   Leap second information. If leapSeconds is not available,
+         timestampUtc is calculated based on a hard-coded value
+         for leap seconds. \n
+         - Units: Seconds */
+
+  /* Optional */
+  /*  GPS Time */
+  uint8_t gpsTime_valid;  /**< Must be set to true if gpsTime is being passed */
+  qmiLocGPSTimeStructT_v02 gpsTime;
+  /**<   \vspace{0.06in} \n The number of weeks since Jan. 5, 1980, and
+       milliseconds into the current week. */
+
+  /* Optional */
+  /*  Time Uncertainty */
+  uint8_t timeUnc_valid;  /**< Must be set to true if timeUnc is being passed */
+  float timeUnc;
+  /**<   Time uncertainty. \n
+       - Units: Milliseconds */
+
+  /* Optional */
+  /*  Time Source */
+  uint8_t timeSrc_valid;  /**< Must be set to true if timeSrc is being passed */
+  qmiLocTimeSourceEnumT_v02 timeSrc;
+  /**<   Time source. Valid values: \n
+      - eQMI_LOC_TIME_SRC_INVALID (0) --  Invalid time.
+      - eQMI_LOC_TIME_SRC_NETWORK_TIME_TRANSFER (1) --  Time is set by the 1X system
+      - eQMI_LOC_TIME_SRC_NETWORK_TIME_TAGGING (2) --  Time is set by WCDMA/GSM time tagging (that is,
+       associating network time with GPS time)
+      - eQMI_LOC_TIME_SRC_EXTERNAL_INPUT (3) --  Time is set by an external injection
+      - eQMI_LOC_TIME_SRC_TOW_DECODE (4) --  Time is set after decoding over-the-air GPS navigation data
+       from one GPS satellite
+      - eQMI_LOC_TIME_SRC_TOW_CONFIRMED (5) --  Time is set after decoding over-the-air GPS navigation data
+       from multiple satellites
+      - eQMI_LOC_TIME_SRC_TOW_AND_WEEK_CONFIRMED (6) --  Both time of the week and the GPS week number are known
+      - eQMI_LOC_TIME_SRC_NAV_SOLUTION (7) --  Time is set by the position engine after the fix is obtained
+      - eQMI_LOC_TIME_SRC_SOLVE_FOR_TIME (8) --  Time is set by the position engine after performing SFT;
+       this is done when the clock time uncertainty is large
+      - eQMI_LOC_TIME_SRC_GLO_TOW_DECODE (9) --  Time is set after decoding GLO satellites
+      - eQMI_LOC_TIME_SRC_TIME_TRANSFORM (10) --  Time is set after transforming the GPS to GLO time
+      - eQMI_LOC_TIME_SRC_WCDMA_SLEEP_TIME_TAGGING (11) --  Time is set by the sleep time tag provided by the WCDMA network
+      - eQMI_LOC_TIME_SRC_GSM_SLEEP_TIME_TAGGING (12) --  Time is set by the sleep time tag provided by the GSM network
+      - eQMI_LOC_TIME_SRC_UNKNOWN (13) --  Source of the time is unknown
+      - eQMI_LOC_TIME_SRC_SYSTEM_TIMETICK (14) --  Time is derived from the system clock (better known as the slow clock);
+       GNSS time is maintained irrespective of the GNSS receiver state
+      - eQMI_LOC_TIME_SRC_QZSS_TOW_DECODE (15) --  Time is set after decoding QZSS satellites
+      - eQMI_LOC_TIME_SRC_BDS_TOW_DECODE (16) --  Time is set after decoding BDS satellites
+      - eQMI_LOC_TIME_SRC_GAL_TOW_DECODE (17) --  Time is set after decoding GAL satellites  */
+
+  /* Optional */
+  /*  Sensor Data Usage */
+  uint8_t sensorDataUsage_valid;  /**< Must be set to true if sensorDataUsage is being passed */
+  qmiLocSensorUsageIndicatorStructT_v02 sensorDataUsage;
+  /**<   \vspace{0.06in} \n Indicates whether sensor data was used in computing the position in this
+       position report. */
+
+  /* Optional */
+  /*  Fix Count for This Session */
+  uint8_t fixId_valid;  /**< Must be set to true if fixId is being passed */
+  uint32_t fixId;
+  /**<   Fix count for the session. Starts with 0 and increments by one
+       for each successive position report for a particular session. */
+
+  /* Optional */
+  /*  SVs Used to Calculate the Fix */
+  uint8_t gnssSvUsedList_valid;  /**< Must be set to true if gnssSvUsedList is being passed */
+  uint32_t gnssSvUsedList_len;  /**< Must be set to # of elements in gnssSvUsedList */
+  uint16_t gnssSvUsedList[QMI_LOC_MAX_SV_USED_LIST_LENGTH_V02];
+  /**<   Each entry in the list contains the SV ID of a satellite
+      used for calculating this position report. The following
+      information is associated with each SV ID: \n
+      Range: \n
+      - For GPS:     1 to 32 \n
+      - For GLONASS: 65 to 96 \n
+      - For QZSS:    193 to 197 \n
+      - For BDS:     201 to 237 \n
+      - For GAL:     301 to 336
+      */
+
+  /* Optional */
+  /*  Altitude Assumed */
+  uint8_t altitudeAssumed_valid;  /**< Must be set to true if altitudeAssumed is being passed */
+  uint8_t altitudeAssumed;
+  /**<   Indicates whether altitude is assumed or calculated: \begin{itemize1}
+         \item    0x00 (FALSE) -- Altitude is calculated
+         \item    0x01 (TRUE) -- Altitude is assumed; there may not be enough
+                                 satellites to determine the precise altitude
+        \vspace{-0.18in} \end{itemize1}*/
+
+  /* Optional */
+  /*   Velocity ENU(East, North, Up) */
+  uint8_t velEnu_valid;  /**< Must be set to true if velEnu is being passed */
+  float velEnu[QMI_LOC_ENU_ARRAY_LENGTH_V02];
+  /**<   East, North, Up velocity.\n
+       - Units: Meters/second */
+
+  /* Optional */
+  /*   Velocity uncertainty ENU(East, North, Up) */
+  uint8_t velUncEnu_valid;  /**< Must be set to true if velUncEnu is being passed */
+  float velUncEnu[QMI_LOC_ENU_ARRAY_LENGTH_V02];
+  /**<   East, North, Up velocity uncertainty.\n
+       - Units: Meters/second */
+}qmiLocEventPositionReportIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCSVSYSTEMENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_SV_SYSTEM_GPS_V02 = 1, /**<  GPS satellite  */
+  eQMI_LOC_SV_SYSTEM_GALILEO_V02 = 2, /**<  GALILEO satellite  */
+  eQMI_LOC_SV_SYSTEM_SBAS_V02 = 3, /**<  SBAS satellite  */
+  eQMI_LOC_SV_SYSTEM_COMPASS_V02 = 4, /**<  COMPASS satellite (Deprecated)  */
+  eQMI_LOC_SV_SYSTEM_GLONASS_V02 = 5, /**<  GLONASS satellite  */
+  eQMI_LOC_SV_SYSTEM_BDS_V02 = 6, /**<  BDS satellite  */
+  eQMI_LOC_SV_SYSTEM_QZSS_V02 = 7, /**<  QZSS satellite  */
+  QMILOCSVSYSTEMENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocSvSystemEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCSVSTATUSENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_SV_STATUS_IDLE_V02 = 1, /**<  SV is not being actively processed  */
+  eQMI_LOC_SV_STATUS_SEARCH_V02 = 2, /**<  The system is searching for this SV  */
+  eQMI_LOC_SV_STATUS_TRACK_V02 = 3, /**<  SV is being tracked  */
+  QMILOCSVSTATUSENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocSvStatusEnumT_v02;
+/**
+    @}
+  */
+
+typedef uint32_t qmiLocSvInfoValidMaskT_v02;
+#define QMI_LOC_SV_INFO_MASK_VALID_SYSTEM_V02 ((qmiLocSvInfoValidMaskT_v02)0x00000001) /**<  System field is valid in SV information  */
+#define QMI_LOC_SV_INFO_MASK_VALID_GNSS_SVID_V02 ((qmiLocSvInfoValidMaskT_v02)0x00000002) /**<  gnssSvId field is valid in SV information  */
+#define QMI_LOC_SV_INFO_MASK_VALID_HEALTH_STATUS_V02 ((qmiLocSvInfoValidMaskT_v02)0x00000004) /**<  healthStatus field is valid in SV information  */
+#define QMI_LOC_SV_INFO_MASK_VALID_PROCESS_STATUS_V02 ((qmiLocSvInfoValidMaskT_v02)0x00000008) /**<  processStatus field is valid in SV information  */
+#define QMI_LOC_SV_INFO_MASK_VALID_SVINFO_MASK_V02 ((qmiLocSvInfoValidMaskT_v02)0x00000010) /**<  svInfoMask field is valid in SV information  */
+#define QMI_LOC_SV_INFO_MASK_VALID_ELEVATION_V02 ((qmiLocSvInfoValidMaskT_v02)0x00000020) /**<  Elevation field is valid in SV information  */
+#define QMI_LOC_SV_INFO_MASK_VALID_AZIMUTH_V02 ((qmiLocSvInfoValidMaskT_v02)0x00000040) /**<  Azimuth field is valid in SV information  */
+#define QMI_LOC_SV_INFO_MASK_VALID_SNR_V02 ((qmiLocSvInfoValidMaskT_v02)0x00000080) /**<  SNR field is valid in SV information  */
+typedef uint8_t qmiLocSvInfoMaskT_v02;
+#define QMI_LOC_SVINFO_MASK_HAS_EPHEMERIS_V02 ((qmiLocSvInfoMaskT_v02)0x01) /**<  Ephemeris is available for this SV  */
+#define QMI_LOC_SVINFO_MASK_HAS_ALMANAC_V02 ((qmiLocSvInfoMaskT_v02)0x02) /**<  Almanac is available for this SV  */
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  qmiLocSvInfoValidMaskT_v02 validMask;
+  /**<   Bitmask indicating which of the fields in this TLV are valid.
+
+         Valid bitmasks: \begin{itemize1}
+         \item    0x00000001 -- VALID_SYSTEM
+         \item    0x00000002 -- VALID_GNSS_SVID
+         \item    0x00000004 -- VALID_HEALTH_ STATUS
+         \item    0x00000008 -- VALID_PROCESS_ STATUS
+         \item    0x00000010 -- VALID_SVINFO_ MASK
+         \item    0x00000020 -- VALID_ELEVATION
+         \item    0x00000040 -- VALID_AZIMUTH
+         \item    0x00000080 -- VALID_SNR
+         \vspace{-0.18in} \end{itemize1}  */
+
+  qmiLocSvSystemEnumT_v02 system;
+  /**<   Indicates to which constellation this SV belongs.
+
+ Valid values: \n
+      - eQMI_LOC_SV_SYSTEM_GPS (1) --  GPS satellite
+      - eQMI_LOC_SV_SYSTEM_GALILEO (2) --  GALILEO satellite
+      - eQMI_LOC_SV_SYSTEM_SBAS (3) --  SBAS satellite
+      - eQMI_LOC_SV_SYSTEM_COMPASS (4) --  COMPASS satellite (Deprecated)
+      - eQMI_LOC_SV_SYSTEM_GLONASS (5) --  GLONASS satellite
+      - eQMI_LOC_SV_SYSTEM_BDS (6) --  BDS satellite
+      - eQMI_LOC_SV_SYSTEM_QZSS (7) --  QZSS satellite
+ */
+
+  uint16_t gnssSvId;
+  /**<   GNSS SV ID.
+         \begin{itemize1}
+         \item Range:  \begin{itemize1}
+           \item For GPS:      1 to 32
+           \item For GLONASS:  1 to 32
+           \item For SBAS:     120 to 158 and 183 to 187
+           \item For QZSS:     193 to 197
+           \item For BDS:      201 to 237
+           \item For GAL:      301 to 336
+         \end{itemize1} \end{itemize1}
+
+        The GPS and GLONASS SVs can be disambiguated using the system field. */
+
+  uint8_t healthStatus;
+  /**<   Health status.
+         \begin{itemize1}
+         \item    Range: 0 to 1; 0 = unhealthy, \n 1 = healthy
+         \vspace{-0.18in} \end{itemize1}*/
+
+  qmiLocSvStatusEnumT_v02 svStatus;
+  /**<   SV processing status.
+
+ Valid values: \n
+      - eQMI_LOC_SV_STATUS_IDLE (1) --  SV is not being actively processed
+      - eQMI_LOC_SV_STATUS_SEARCH (2) --  The system is searching for this SV
+      - eQMI_LOC_SV_STATUS_TRACK (3) --  SV is being tracked
+ */
+
+  qmiLocSvInfoMaskT_v02 svInfoMask;
+  /**<   Indicates whether almanac and ephemeris information is available. \n
+         Valid bitmasks:
+
+           - 0x01 -- SVINFO_HAS_EPHEMERIS \n
+           - 0x02 -- SVINFO_HAS_ALMANAC
+    */
+
+  float elevation;
+  /**<   SV elevation angle.\n
+         - Units: Degrees \n
+         - Range: 0 to 90 */
+
+  float azimuth;
+  /**<   SV azimuth angle.\n
+         - Units: Degrees \n
+         - Range: 0 to 360 */
+
+  float snr;
+  /**<   SV signal-to-noise ratio. \n
+         - Units: dB-Hz */
+}qmiLocSvInfoStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Sends a satellite report to the control point. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Altitude Assumed */
+  uint8_t altitudeAssumed;
+  /**<   Indicates whether altitude is assumed or calculated: \begin{itemize1}
+         \item    0x00 (FALSE) -- Valid altitude is calculated
+         \item    0x01 (TRUE) -- Valid altitude is assumed; there may not be
+                                 enough satellites to determine precise altitude
+          \vspace{-0.18in} \end{itemize1}*/
+
+  /* Optional */
+  /*  Satellite Info */
+  uint8_t svList_valid;  /**< Must be set to true if svList is being passed */
+  uint32_t svList_len;  /**< Must be set to # of elements in svList */
+  qmiLocSvInfoStructT_v02 svList[QMI_LOC_SV_INFO_LIST_MAX_SIZE_V02];
+  /**<   \vspace{0.06in} \n SV information list. */
+}qmiLocEventGnssSvInfoIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Sends NMEA sentences to the control point */
+typedef struct {
+
+  /* Mandatory */
+  /*  NMEA String */
+  char nmea[QMI_LOC_NMEA_STRING_MAX_LENGTH_V02 + 1];
+  /**<   NMEA string.
+       \begin{itemize1}
+       \item    Type: NULL-terminated string
+       \item    Maximum string length (including NULL terminator): 201
+       \vspace{-0.18in} \end{itemize1}*/
+}qmiLocEventNmeaIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCNINOTIFYVERIFYENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_NI_USER_NO_NOTIFY_NO_VERIFY_V02 = 1, /**<  No notification and no verification required  */
+  eQMI_LOC_NI_USER_NOTIFY_ONLY_V02 = 2, /**<  Notify only; no verification required  */
+  eQMI_LOC_NI_USER_NOTIFY_VERIFY_ALLOW_NO_RESP_V02 = 3, /**<  Notify and verify, but no response required.  */
+  eQMI_LOC_NI_USER_NOTIFY_VERIFY_NOT_ALLOW_NO_RESP_V02 = 4, /**<  Notify and verify, and require a response  */
+  eQMI_LOC_NI_USER_NOTIFY_VERIFY_PRIVACY_OVERRIDE_V02 = 5, /**<  Notify and verify; privacy override  */
+  QMILOCNINOTIFYVERIFYENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocNiNotifyVerifyEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCNIVXPOSMODEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_NI_VX_MS_ASSISTED_ONLY_V02 = 1, /**<  MS-assisted only allowed  */
+  eQMI_LOC_NI_VX_MS_BASED_ONLY_V02 = 2, /**<  MS-based only allowed  */
+  eQMI_LOC_NI_VX_MS_ASSISTED_PREFERRED_MS_BASED_ALLOWED_V02 = 3, /**<  MS-assisted preferred, but MS-based allowed  */
+  eQMI_LOC_NI_VX_MS_BASED_PREFERRED_MS_ASSISTED_ALLOWED_V02 = 4, /**<  MS-based preferred, but MS-assisted allowed  */
+  QMILOCNIVXPOSMODEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocNiVxPosModeEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCNIVXREQUESTORIDENCODINGSCHEMEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_NI_VX_OCTET_V02 = 0, /**<  Encoding is Octet  */
+  eQMI_LOC_NI_VX_EXN_PROTOCOL_MSG_V02 = 1, /**<  Encoding is EXN protocol message  */
+  eQMI_LOC_NI_VX_ASCII_V02 = 2, /**<  Encoding is ASCII  */
+  eQMI_LOC_NI_VX_IA5_V02 = 3, /**<  Encoding is IA5  */
+  eQMI_LOC_NI_VX_UNICODE_V02 = 4, /**<  Encoding is Unicode  */
+  eQMI_LOC_NI_VX_SHIFT_JIS_V02 = 5, /**<  Encoding is Shift JIS  */
+  eQMI_LOC_NI_VX_KOREAN_V02 = 6, /**<  Encoding is Korean  */
+  eQMI_LOC_NI_VX_LATIN_HEBREW_V02 = 7, /**<  Encoding is Latin Hebrew  */
+  eQMI_LOC_NI_VX_LATIN_V02 = 8, /**<  Encoding is Latin  */
+  eQMI_LOC_NI_VX_GSM_V02 = 9, /**<  Encoding is GSM  */
+  QMILOCNIVXREQUESTORIDENCODINGSCHEMEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocNiVxRequestorIdEncodingSchemeEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint8_t posQosIncl;
+  /**<   Indicates whether quality of service is included:\n
+         - 0x01 (TRUE) --  QoS is included \n
+         - 0x00 (FALSE) -- QoS is not included */
+
+  uint8_t posQos;
+  /**<   Position QoS timeout. \n
+         - Units: Seconds \n
+         - Range: 0 to 255 */
+
+  uint32_t numFixes;
+  /**<   Number of fixes allowed. */
+
+  uint32_t timeBetweenFixes;
+  /**<   Time between fixes. \n
+         - Units: Seconds */
+
+  qmiLocNiVxPosModeEnumT_v02 posMode;
+  /**<   Position mode.
+ Valid values:
+
+      - eQMI_LOC_NI_VX_MS_ASSISTED_ONLY (1) --  MS-assisted only allowed
+      - eQMI_LOC_NI_VX_MS_BASED_ONLY (2) --  MS-based only allowed
+      - eQMI_LOC_NI_VX_MS_ASSISTED_PREFERRED_MS_BASED_ALLOWED (3) --  MS-assisted preferred, but MS-based allowed
+      - eQMI_LOC_NI_VX_MS_BASED_PREFERRED_MS_ASSISTED_ALLOWED (4) --  MS-based preferred, but MS-assisted allowed
+ */
+
+  qmiLocNiVxRequestorIdEncodingSchemeEnumT_v02 encodingScheme;
+  /**<   VX encoding scheme.
+
+ Valid values:
+
+      - eQMI_LOC_NI_VX_OCTET (0) --  Encoding is Octet
+      - eQMI_LOC_NI_VX_EXN_PROTOCOL_MSG (1) --  Encoding is EXN protocol message
+      - eQMI_LOC_NI_VX_ASCII (2) --  Encoding is ASCII
+      - eQMI_LOC_NI_VX_IA5 (3) --  Encoding is IA5
+      - eQMI_LOC_NI_VX_UNICODE (4) --  Encoding is Unicode
+      - eQMI_LOC_NI_VX_SHIFT_JIS (5) --  Encoding is Shift JIS
+      - eQMI_LOC_NI_VX_KOREAN (6) --  Encoding is Korean
+      - eQMI_LOC_NI_VX_LATIN_HEBREW (7) --  Encoding is Latin Hebrew
+      - eQMI_LOC_NI_VX_LATIN (8) --  Encoding is Latin
+      - eQMI_LOC_NI_VX_GSM (9) --  Encoding is GSM
+ */
+
+  uint32_t requestorId_len;  /**< Must be set to # of elements in requestorId */
+  uint8_t requestorId[QMI_LOC_NI_MAX_REQUESTOR_ID_LENGTH_V02];
+  /**<   Requestor ID. \n
+       - Type:  Array of bytes \n
+       - Maximum array length: 200
+  */
+
+  uint16_t userRespTimerInSeconds;
+  /**<   Time to wait for the user to respond. \n
+         - Units: Seconds */
+}qmiLocNiVxNotifyVerifyStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCNISUPLPOSMETHODENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_NI_SUPL_POSMETHOD_AGPS_SETASSISTED_V02 = 1, /**<  Set assisted  */
+  eQMI_LOC_NI_SUPL_POSMETHOD_AGPS_SETBASED_V02 = 2, /**<  Set based  */
+  eQMI_LOC_NI_SUPL_POSMETHOD_AGPS_SETASSISTED_PREF_V02 = 3, /**<  Set assisted preferred  */
+  eQMI_LOC_NI_SUPL_POSMETHOD_AGPS_SETBASED_PREF_V02 = 4, /**<  Set based preferred  */
+  eQMI_LOC_NI_SUPL_POSMETHOD_AUTONOMOUS_GPS_V02 = 5, /**<  Standalone GPS  */
+  eQMI_LOC_NI_SUPL_POSMETHOD_AFLT_V02 = 6, /**<  Advanced forward link trilateration  */
+  eQMI_LOC_NI_SUPL_POSMETHOD_ECID_V02 = 7, /**<  Exclusive chip ID  */
+  eQMI_LOC_NI_SUPL_POSMETHOD_EOTD_V02 = 8, /**<  Enhnaced observed time difference  */
+  eQMI_LOC_NI_SUPL_POSMETHOD_OTDOA_V02 = 9, /**<  Observed time delay of arrival  */
+  eQMI_LOC_NI_SUPL_POSMETHOD_NO_POSITION_V02 = 10, /**<  No position  */
+  QMILOCNISUPLPOSMETHODENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocNiSuplPosMethodEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCNIDATACODINGSCHEMEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_NI_SS_GERMAN_V02 = 12, /**<  Language is German  */
+  eQMI_LOC_NI_SS_ENGLISH_V02 = 13, /**<  Language is English  */
+  eQMI_LOC_NI_SS_ITALIAN_V02 = 14, /**<  Language is Italian  */
+  eQMI_LOC_NI_SS_FRENCH_V02 = 15, /**<  Language is French  */
+  eQMI_LOC_NI_SS_SPANISH_V02 = 16, /**<  Language is Spanish  */
+  eQMI_LOC_NI_SS_DUTCH_V02 = 17, /**<  Language is Dutch  */
+  eQMI_LOC_NI_SS_SWEDISH_V02 = 18, /**<  Language is Swedish  */
+  eQMI_LOC_NI_SS_DANISH_V02 = 19, /**<  Language is Danish  */
+  eQMI_LOC_NI_SS_PORTUGUESE_V02 = 20, /**<  Language is Portuguese  */
+  eQMI_LOC_NI_SS_FINNISH_V02 = 21, /**<  Language is Finnish  */
+  eQMI_LOC_NI_SS_NORWEGIAN_V02 = 22, /**<  Language is Norwegian  */
+  eQMI_LOC_NI_SS_GREEK_V02 = 23, /**<  Language is Greek  */
+  eQMI_LOC_NI_SS_TURKISH_V02 = 24, /**<  Language is Turkish  */
+  eQMI_LOC_NI_SS_HUNGARIAN_V02 = 25, /**<  Language is Hungarian  */
+  eQMI_LOC_NI_SS_POLISH_V02 = 26, /**<  Language is Polish  */
+  eQMI_LOC_NI_SS_LANGUAGE_UNSPEC_V02 = 27, /**<  Language is unspecified  */
+  eQMI_LOC_NI_SUPL_UTF8_V02 = 28, /**<  Encoding is UTF 8  */
+  eQMI_LOC_NI_SUPL_UCS2_V02 = 29, /**<  Encoding is UCS 2  */
+  eQMI_LOC_NI_SUPL_GSM_DEFAULT_V02 = 30, /**<  Encoding is GSM default  */
+  QMILOCNIDATACODINGSCHEMEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocNiDataCodingSchemeEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCNISUPLFORMATENUMTYPE_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_NI_SUPL_FORMAT_LOGICAL_NAME_V02 = 0, /**<  SUPL logical name format  */
+  eQMI_LOC_NI_SUPL_FORMAT_EMAIL_ADDRESS_V02 = 1, /**<  SUPL email address format  */
+  eQMI_LOC_NI_SUPL_FORMAT_MSISDN_V02 = 2, /**<  SUPL MS-ISDN format  */
+  eQMI_LOC_NI_SUPL_FORMAT_URL_V02 = 3, /**<  SUPL URL format  */
+  eQMI_LOC_NI_SUPL_FORMAT_SIP_URL_V02 = 4, /**<  SUPL SIP URL format  */
+  eQMI_LOC_NI_SUPL_FORMAT_MIN_V02 = 5, /**<  SUPL MIN format  */
+  eQMI_LOC_NI_SUPL_FORMAT_MDN_V02 = 6, /**<  SUPL MDN format  */
+  eQMI_LOC_NI_SUPL_FORMAT_IMSPUBLIC_IDENTITY_V02 = 7, /**<  SUPL IMS public identity  */
+  eQMI_LOC_NI_SUPL_FORMAT_OSS_UNKNOWN_V02 = 2147483647, /**<  SUPL unknown format  */
+  QMILOCNISUPLFORMATENUMTYPE_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocNiSuplFormatEnumType_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  qmiLocNiSuplFormatEnumType_v02 formatType;
+  /**<   Format of the formatted string.
+
+ Valid values: \n
+      - eQMI_LOC_NI_SUPL_FORMAT_LOGICAL_NAME (0) --  SUPL logical name format
+      - eQMI_LOC_NI_SUPL_FORMAT_EMAIL_ADDRESS (1) --  SUPL email address format
+      - eQMI_LOC_NI_SUPL_FORMAT_MSISDN (2) --  SUPL MS-ISDN format
+      - eQMI_LOC_NI_SUPL_FORMAT_URL (3) --  SUPL URL format
+      - eQMI_LOC_NI_SUPL_FORMAT_SIP_URL (4) --  SUPL SIP URL format
+      - eQMI_LOC_NI_SUPL_FORMAT_MIN (5) --  SUPL MIN format
+      - eQMI_LOC_NI_SUPL_FORMAT_MDN (6) --  SUPL MDN format
+      - eQMI_LOC_NI_SUPL_FORMAT_IMSPUBLIC_IDENTITY (7) --  SUPL IMS public identity
+      - eQMI_LOC_NI_SUPL_FORMAT_OSS_UNKNOWN (2147483647) --  SUPL unknown format
+ */
+
+  uint32_t formattedString_len;  /**< Must be set to # of elements in formattedString */
+  uint8_t formattedString[QMI_LOC_NI_MAX_CLIENT_NAME_LENGTH_V02];
+  /**<   Formatted string. \n
+        - Type: Byte array \n
+        - Maximum string length: 64
+   */
+}qmiLocNiSuplFormattedStringStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+typedef uint8_t qmiLocSuplQopValidMaskT_v02;
+#define QMI_LOC_NI_SUPL_MASK_QOP_HORZ_ACC_VALID_V02 ((qmiLocSuplQopValidMaskT_v02)0x01) /**<  Horizontal accuracy is valid in the Quality of Position (QoP)  */
+#define QMI_LOC_NI_SUPL_MASK_QOP_VER_ACC_VALID_V02 ((qmiLocSuplQopValidMaskT_v02)0x02) /**<  Vertical accuracy is valid in the QoP  */
+#define QMI_LOC_NI_SUPL_MASK_QOP_MAXAGE_VALID_V02 ((qmiLocSuplQopValidMaskT_v02)0x04) /**<  Vertical accuracy is valid in the QoP  */
+#define QMI_LOC_NI_SUPL_MASK_QOP_DELAY_VALID_V02 ((qmiLocSuplQopValidMaskT_v02)0x08) /**<  Vertical accuracy is valid in the QoP  */
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  qmiLocSuplQopValidMaskT_v02 validMask;
+  /**<   Bit field indicating which fields are valid in this value.
+
+        Valid bitmasks: \n
+          - 0x01 -- QOP_HORZ_ACC_VALID \n
+          - 0x02 -- QOP_VER_ACC_VALID \n
+          - 0x04 -- QOP_MAXAGE_VALID \n
+          - 0x08 -- QOP_DELAY_VALID*/
+
+  uint8_t horizontalAccuracy;
+  /**<   Horizontal accuracy. \n
+        - Units: Meters */
+
+  uint8_t verticalAccuracy;
+  /**<   Vertical accuracy. \n
+        - Units: Meters */
+
+  uint16_t maxLocAge;
+  /**<   Maximum age of the location if the engine sends a previously
+        computed position. \n
+        - Units: Seconds */
+
+  uint8_t delay;
+  /**<   Delay the server is willing to tolerate for the fix. \n
+        - Units: Seconds */
+}qmiLocNiSuplQopStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+typedef uint8_t qmiLocServerAddrTypeMaskT_v02;
+#define QMI_LOC_SERVER_ADDR_TYPE_IPV4_MASK_V02 ((qmiLocServerAddrTypeMaskT_v02)0x01) /**<  IPv4 server address type  */
+#define QMI_LOC_SERVER_ADDR_TYPE_IPV6_MASK_V02 ((qmiLocServerAddrTypeMaskT_v02)0x02) /**<  IPv6 server address type  */
+#define QMI_LOC_SERVER_ADDR_TYPE_URL_MASK_V02 ((qmiLocServerAddrTypeMaskT_v02)0x04) /**<  URL server address type  */
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint32_t addr;
+  /**<   IPv4 address. */
+
+  uint16_t port;
+  /**<   IPv4 port. */
+}qmiLocIpV4AddrStructType_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint16_t addr[QMI_LOC_IPV6_ADDR_LENGTH_V02];
+  /**<   IPv6 address. \n
+       - Type: Array of unsigned integers \n
+       - Maximum length of the array: 8 */
+
+  uint32_t port;
+  /**<   IPv6 port. */
+}qmiLocIpV6AddrStructType_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  qmiLocServerAddrTypeMaskT_v02 suplServerAddrTypeMask;
+  /**<   Mask specifying the valid fields in this value.
+
+       Valid bitmasks: \n
+         - 0x01 -- IPv4 \n
+         - 0x02 -- IPv6 \n
+         - 0x04 -- URL
+  */
+
+  qmiLocIpV4AddrStructType_v02 ipv4Addr;
+  /**<   IPv4 address and port. */
+
+  qmiLocIpV6AddrStructType_v02 ipv6Addr;
+  /**<   IPv6 address and port. */
+
+  char urlAddr[QMI_LOC_MAX_SERVER_ADDR_LENGTH_V02 + 1];
+  /**<   URL.
+       \begin{itemize1}
+       \item    Type: NULL-terminated string
+       \item    Maximum string length (including NULL terminator): 256
+       \vspace{-0.18in} \end{itemize1}
+        */
+}qmiLocNiSuplServerInfoStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+typedef uint32_t qmiLocNiSuplNotifyVerifyValidMaskT_v02;
+#define QMI_LOC_SUPL_SERVER_INFO_MASK_V02 ((qmiLocNiSuplNotifyVerifyValidMaskT_v02)0x00000001) /**<  Mask to denote that the server information
+      is present in an NI SUPL Notify/Verify request event. This mask is set in
+     the valid_flags field of a Notify/Verify structure.  */
+#define QMI_LOC_SUPL_SESSION_ID_MASK_V02 ((qmiLocNiSuplNotifyVerifyValidMaskT_v02)0x00000002) /**<  Mask to denote that the SUPL session ID
+       is present in an NI SUPL Notify/Verify request event.
+      This mask is set in the valid_flags field of a
+      Notify/Verify structure.   */
+#define QMI_LOC_SUPL_HASH_MASK_V02 ((qmiLocNiSuplNotifyVerifyValidMaskT_v02)0x00000004) /**<  Mask to denote that the SUPL hash is present
+       in an NI Notify/Verify request event.
+      This mask is set in the valid_flags field of a
+      Notify/Verify structure.   */
+#define QMI_LOC_SUPL_POS_METHOD_MASK_V02 ((qmiLocNiSuplNotifyVerifyValidMaskT_v02)0x00000008) /**<  Mask to denote that the position method is present
+       in an NI SUPL Notify/Verify request event.
+      This mask is set in the valid_flags field of a
+      Notify/Verify structure.  */
+#define QMI_LOC_SUPL_DATA_CODING_SCHEME_MASK_V02 ((qmiLocNiSuplNotifyVerifyValidMaskT_v02)0x00000010) /**<  Mask to denote that the data coding scheme
+       is present in an NI SUPL Notify/Verify request event.
+      This mask is set in the valid_flags field of a
+      Notify/Verify structure.  */
+#define QMI_LOC_SUPL_REQUESTOR_ID_MASK_V02 ((qmiLocNiSuplNotifyVerifyValidMaskT_v02)0x00000020) /**<  Mask to denote that the requestor ID
+       is present in an NI Notify/Verify request event.
+      This mask is set in the valid_flags field of a
+      Notify/Verify structure.  */
+#define QMI_LOC_SUPL_CLIENT_NAME_MASK_V02 ((qmiLocNiSuplNotifyVerifyValidMaskT_v02)0x00000040) /**<  Mask to denote that the requestor ID
+       is present in an NI Notify/Verify request event.
+       This mask is set in the valid_flags field of a
+       Notify/Verify structure.  */
+#define QMI_LOC_SUPL_QOP_MASK_V02 ((qmiLocNiSuplNotifyVerifyValidMaskT_v02)0x00000080) /**<  Mask to denote that the quality of position
+       is present in an NI Notify/Verify request event.
+       This mask is set in the valid_flags field of a
+       Notify/Verify structure.  */
+#define QMI_LOC_SUPL_USER_RESP_TIMER_MASK_V02 ((qmiLocNiSuplNotifyVerifyValidMaskT_v02)0x00000100) /**<  Mask to denote that the user response timer
+       is present in an NI Notify/Verify request event.
+       This mask is set in the valid_flags field of a
+       Notify/Verify structure.  */
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  qmiLocNiSuplNotifyVerifyValidMaskT_v02 valid_flags;
+  /**<   Indicates which of the following fields are present in this value.
+
+        Valid bitmasks: \begin{itemize1}
+        \item    0x00000001 -- SUPL_SERVER_INFO
+        \item    0x00000002 -- SUPL_SESSION_ID
+        \item    0x00000004 -- SUPL_HASH
+        \item    0x00000008 -- SUPL_POS_METHOD
+        \item    0x00000010 -- SUPL_DATA_ CODING_SCHEME
+        \item    0x00000020 -- SUPL_REQUESTOR_ ID
+        \item    0x00000040 -- SUPL_CLIENT_ NAME
+        \item    0x00000080 -- SUPL_QOP
+        \item    0x00000100 -- SUPL_USER_RESP_ TIMER
+        \vspace{-0.18in} \end{itemize1}
+  */
+
+  qmiLocNiSuplServerInfoStructT_v02 suplServerInfo;
+  /**<   SUPL server information. */
+
+  uint8_t suplSessionId[QMI_LOC_NI_SUPL_SLP_SESSION_ID_BYTE_LENGTH_V02];
+  /**<   SUPL session ID. \n
+       - Type: Array of unsigned integers \n
+       - Maximum length of the array: 4 */
+
+  uint8_t suplHash[QMI_LOC_NI_SUPL_HASH_LENGTH_V02];
+  /**<   Hash for SUPL_INIT; used to validate that the message was not
+       corrupted. \n
+       - Type: Array of unsigned integers \n
+       - Length of the array: 8 */
+
+  qmiLocNiSuplPosMethodEnumT_v02 posMethod;
+  /**<   GPS mode to be used for the fix.
+ Valid values:
+
+      - eQMI_LOC_NI_SUPL_POSMETHOD_AGPS_SETASSISTED (1) --  Set assisted
+      - eQMI_LOC_NI_SUPL_POSMETHOD_AGPS_SETBASED (2) --  Set based
+      - eQMI_LOC_NI_SUPL_POSMETHOD_AGPS_SETASSISTED_PREF (3) --  Set assisted preferred
+      - eQMI_LOC_NI_SUPL_POSMETHOD_AGPS_SETBASED_PREF (4) --  Set based preferred
+      - eQMI_LOC_NI_SUPL_POSMETHOD_AUTONOMOUS_GPS (5) --  Standalone GPS
+      - eQMI_LOC_NI_SUPL_POSMETHOD_AFLT (6) --  Advanced forward link trilateration
+      - eQMI_LOC_NI_SUPL_POSMETHOD_ECID (7) --  Exclusive chip ID
+      - eQMI_LOC_NI_SUPL_POSMETHOD_EOTD (8) --  Enhnaced observed time difference
+      - eQMI_LOC_NI_SUPL_POSMETHOD_OTDOA (9) --  Observed time delay of arrival
+      - eQMI_LOC_NI_SUPL_POSMETHOD_NO_POSITION (10) --  No position
+ */
+
+  qmiLocNiDataCodingSchemeEnumT_v02 dataCodingScheme;
+  /**<   Data coding scheme applies to both the requestor ID and the client
+ name.
+
+ Valid values: \n
+      - eQMI_LOC_NI_SS_GERMAN (12) --  Language is German
+      - eQMI_LOC_NI_SS_ENGLISH (13) --  Language is English
+      - eQMI_LOC_NI_SS_ITALIAN (14) --  Language is Italian
+      - eQMI_LOC_NI_SS_FRENCH (15) --  Language is French
+      - eQMI_LOC_NI_SS_SPANISH (16) --  Language is Spanish
+      - eQMI_LOC_NI_SS_DUTCH (17) --  Language is Dutch
+      - eQMI_LOC_NI_SS_SWEDISH (18) --  Language is Swedish
+      - eQMI_LOC_NI_SS_DANISH (19) --  Language is Danish
+      - eQMI_LOC_NI_SS_PORTUGUESE (20) --  Language is Portuguese
+      - eQMI_LOC_NI_SS_FINNISH (21) --  Language is Finnish
+      - eQMI_LOC_NI_SS_NORWEGIAN (22) --  Language is Norwegian
+      - eQMI_LOC_NI_SS_GREEK (23) --  Language is Greek
+      - eQMI_LOC_NI_SS_TURKISH (24) --  Language is Turkish
+      - eQMI_LOC_NI_SS_HUNGARIAN (25) --  Language is Hungarian
+      - eQMI_LOC_NI_SS_POLISH (26) --  Language is Polish
+      - eQMI_LOC_NI_SS_LANGUAGE_UNSPEC (27) --  Language is unspecified
+      - eQMI_LOC_NI_SUPL_UTF8 (28) --  Encoding is UTF 8
+      - eQMI_LOC_NI_SUPL_UCS2 (29) --  Encoding is UCS 2
+      - eQMI_LOC_NI_SUPL_GSM_DEFAULT (30) --  Encoding is GSM default
+ */
+
+  qmiLocNiSuplFormattedStringStructT_v02 requestorId;
+  /**<   Requestor ID. The encoding scheme for requestor_id is specified in
+       the dataCodingScheme field. */
+
+  qmiLocNiSuplFormattedStringStructT_v02 clientName;
+  /**<   Client name. The encoding scheme for client_name is specified in
+       the dataCodingScheme field. */
+
+  qmiLocNiSuplQopStructT_v02 suplQop;
+  /**<   SUPL QoP. */
+
+  uint16_t userResponseTimer;
+  /**<   Time to wait for the user to respond. \n
+       - Units: Seconds*/
+}qmiLocNiSuplNotifyVerifyStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCNILOCATIONTYPEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_NI_LOCATIONTYPE_CURRENT_LOCATION_V02 = 1, /**<  Current location  */
+  eQMI_LOC_NI_LOCATIONTYPE_CURRENT_OR_LAST_KNOWN_LOCATION_V02 = 2, /**<  Last known location; may be the current location  */
+  eQMI_LOC_NI_LOCATIONTYPE_INITIAL_LOCATION_V02 = 3, /**<  Initial location  */
+  QMILOCNILOCATIONTYPEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocNiLocationTypeEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  qmiLocNiDataCodingSchemeEnumT_v02 dataCodingScheme;
+  /**<   Identifies the coding scheme of the coded string.
+
+ Valid values: \n
+      - eQMI_LOC_NI_SS_GERMAN (12) --  Language is German
+      - eQMI_LOC_NI_SS_ENGLISH (13) --  Language is English
+      - eQMI_LOC_NI_SS_ITALIAN (14) --  Language is Italian
+      - eQMI_LOC_NI_SS_FRENCH (15) --  Language is French
+      - eQMI_LOC_NI_SS_SPANISH (16) --  Language is Spanish
+      - eQMI_LOC_NI_SS_DUTCH (17) --  Language is Dutch
+      - eQMI_LOC_NI_SS_SWEDISH (18) --  Language is Swedish
+      - eQMI_LOC_NI_SS_DANISH (19) --  Language is Danish
+      - eQMI_LOC_NI_SS_PORTUGUESE (20) --  Language is Portuguese
+      - eQMI_LOC_NI_SS_FINNISH (21) --  Language is Finnish
+      - eQMI_LOC_NI_SS_NORWEGIAN (22) --  Language is Norwegian
+      - eQMI_LOC_NI_SS_GREEK (23) --  Language is Greek
+      - eQMI_LOC_NI_SS_TURKISH (24) --  Language is Turkish
+      - eQMI_LOC_NI_SS_HUNGARIAN (25) --  Language is Hungarian
+      - eQMI_LOC_NI_SS_POLISH (26) --  Language is Polish
+      - eQMI_LOC_NI_SS_LANGUAGE_UNSPEC (27) --  Language is unspecified
+      - eQMI_LOC_NI_SUPL_UTF8 (28) --  Encoding is UTF 8
+      - eQMI_LOC_NI_SUPL_UCS2 (29) --  Encoding is UCS 2
+      - eQMI_LOC_NI_SUPL_GSM_DEFAULT (30) --  Encoding is GSM default
+ */
+
+  uint32_t codedString_len;  /**< Must be set to # of elements in codedString */
+  uint8_t codedString[QMI_LOC_NI_CODEWORD_MAX_LENGTH_V02];
+  /**<   Coded string. \n
+       - Type: Array of bytes \n
+       - Maximum string length: 20 */
+}qmiLocNiUmtsCpCodedStringStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+typedef uint16_t qmiLocNiUmtsCpNotifyVerifyValidMaskT_v02;
+#define QMI_LOC_UMTS_CP_INVOKE_ID_MASK_V02 ((qmiLocNiUmtsCpNotifyVerifyValidMaskT_v02)0x0001) /**<  Mask to denote that the invoke ID
+       is present in an NI Notify/Verify request event.
+      This mask is set in the valid flags field of a
+       Notify/Verify structure.  */
+#define QMI_LOC_UMTS_CP_DATA_CODING_SCHEME_MASK_V02 ((qmiLocNiUmtsCpNotifyVerifyValidMaskT_v02)0x0002) /**<  Mask to denote that the data coding scheme
+       is present in an NI Notify/Verify request event.
+       This mask is set in the valid flags field of a
+       Notify/Verify structure.  */
+#define QMI_LOC_UMTS_CP_NOTIFICATION_TEXT_MASK_V02 ((qmiLocNiUmtsCpNotifyVerifyValidMaskT_v02)0x0004) /**<  Mask to denote that the notification text
+       is present in an NI Notify/Verify request event.
+      This mask is set in the valid flags field of a
+       Notify/Verify structure.  */
+#define QMI_LOC_UMTS_CP_CLIENT_ADDRESS_MASK_V02 ((qmiLocNiUmtsCpNotifyVerifyValidMaskT_v02)0x0008) /**<  Mask to denote that the client address
+       is present in an NI Notify/Verify request event.
+      This mask is set in the valid flags field of a
+       Notify/Verify structure.  */
+#define QMI_LOC_UMTS_CP_LOCATION_TYPE_MASK_V02 ((qmiLocNiUmtsCpNotifyVerifyValidMaskT_v02)0x0010) /**<  Mask to denote that the location type
+       is present in an NI Notify/Verify request event.
+       This mask is set in the valid flags field of a
+       Notify/Verify structure.  */
+#define QMI_LOC_UMTS_CP_REQUESTOR_ID_MASK_V02 ((qmiLocNiUmtsCpNotifyVerifyValidMaskT_v02)0x0020) /**<  Mask to denote that the requestor ID
+       is present in an NI Notify/Verify request event.
+       This mask is set in the valid flags field of a
+       Notify/Verify structure.  */
+#define QMI_LOC_UMTS_CP_CODEWORD_STRING_MASK_V02 ((qmiLocNiUmtsCpNotifyVerifyValidMaskT_v02)0x0040) /**<  Mask to denote that the code word string
+       is present in an NI Notify/Verify request event.
+       This mask is set in the valid flags field of a
+       Notify/Verify structure.  */
+#define QMI_LOC_UMTS_CP_SERVICE_TYPE_MASK_V02 ((qmiLocNiUmtsCpNotifyVerifyValidMaskT_v02)0x0080) /**<  Mask to denote that the service type
+       is present in an NI Notify/Verify request event.
+       This mask is set in the valid flags field of a
+       Notify/Verify structure.  */
+#define QMI_LOC_UMTS_CP_USER_RESP_TIMER_MASK_V02 ((qmiLocNiUmtsCpNotifyVerifyValidMaskT_v02)0x0100) /**<  Mask to denote that the user response timer
+       is present in an NI Notify/Verify request event.
+       This mask is set in the valid flags field of a
+       Notify/Verify structure.  */
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  qmiLocNiUmtsCpNotifyVerifyValidMaskT_v02 valid_flags;
+  /**<   Fields that are valid in this value.
+
+       Valid bitmasks: \begin{itemize1}
+       \item    0x0001 -- INVOKE_ID_MASK
+       \item    0x0002 -- DATA_CODING_ SCHEME_MASK
+       \item    0x0004 -- NOTIFICATION_TEXT_ MASK
+       \item    0x0008 -- CLIENT_ADDRESS_ MASK
+       \item    0x0010 -- LOCATION_TYPE_ MASK
+       \item    0x0020 -- REQUESTOR_ID_MASK
+       \item    0x0040 -- CODEWORD_STRING_ MASK
+       \item    0x0080 -- SERVICE_TYPE_MASK
+       \item    0x0100 -- USER_RESP_TIMER_ MASK
+       \vspace{-0.18in} \end{itemize1}
+  */
+
+  uint8_t invokeId;
+  /**<   Supplementary Services invoke ID. */
+
+  qmiLocNiDataCodingSchemeEnumT_v02 dataCodingScheme;
+  /**<   Type of data encoding scheme for the text.
+ Applies to both the notification text and the client address.
+
+ Valid values: \n
+      - eQMI_LOC_NI_SS_GERMAN (12) --  Language is German
+      - eQMI_LOC_NI_SS_ENGLISH (13) --  Language is English
+      - eQMI_LOC_NI_SS_ITALIAN (14) --  Language is Italian
+      - eQMI_LOC_NI_SS_FRENCH (15) --  Language is French
+      - eQMI_LOC_NI_SS_SPANISH (16) --  Language is Spanish
+      - eQMI_LOC_NI_SS_DUTCH (17) --  Language is Dutch
+      - eQMI_LOC_NI_SS_SWEDISH (18) --  Language is Swedish
+      - eQMI_LOC_NI_SS_DANISH (19) --  Language is Danish
+      - eQMI_LOC_NI_SS_PORTUGUESE (20) --  Language is Portuguese
+      - eQMI_LOC_NI_SS_FINNISH (21) --  Language is Finnish
+      - eQMI_LOC_NI_SS_NORWEGIAN (22) --  Language is Norwegian
+      - eQMI_LOC_NI_SS_GREEK (23) --  Language is Greek
+      - eQMI_LOC_NI_SS_TURKISH (24) --  Language is Turkish
+      - eQMI_LOC_NI_SS_HUNGARIAN (25) --  Language is Hungarian
+      - eQMI_LOC_NI_SS_POLISH (26) --  Language is Polish
+      - eQMI_LOC_NI_SS_LANGUAGE_UNSPEC (27) --  Language is unspecified
+      - eQMI_LOC_NI_SUPL_UTF8 (28) --  Encoding is UTF 8
+      - eQMI_LOC_NI_SUPL_UCS2 (29) --  Encoding is UCS 2
+      - eQMI_LOC_NI_SUPL_GSM_DEFAULT (30) --  Encoding is GSM default
+ */
+
+  uint32_t notificationText_len;  /**< Must be set to # of elements in notificationText */
+  uint8_t notificationText[QMI_LOC_NI_MAX_CLIENT_NAME_LENGTH_V02];
+  /**<   Notification text; the encoding method is specified in
+       dataCodingScheme. \n
+       - Type: Array of bytes \n
+       - Maximum array length: 64 */
+
+  uint32_t clientAddress_len;  /**< Must be set to # of elements in clientAddress */
+  uint8_t clientAddress[QMI_LOC_NI_MAX_EXT_CLIENT_ADDRESS_V02];
+  /**<   Client address; the encoding method is specified in
+       dataCodingScheme. \n
+       - Maximum array length: 20 */
+
+  qmiLocNiLocationTypeEnumT_v02 locationType;
+  /**<   Location type.
+
+ Valid values: \n
+      - eQMI_LOC_NI_LOCATIONTYPE_CURRENT_LOCATION (1) --  Current location
+      - eQMI_LOC_NI_LOCATIONTYPE_CURRENT_OR_LAST_KNOWN_LOCATION (2) --  Last known location; may be the current location
+      - eQMI_LOC_NI_LOCATIONTYPE_INITIAL_LOCATION (3) --  Initial location
+ */
+
+  qmiLocNiUmtsCpCodedStringStructT_v02 requestorId;
+  /**<   Requestor ID; the encoding method is specified in the
+       qmiLocNiUmtsCpCodedStringStructT.dataCodingScheme field. */
+
+  qmiLocNiUmtsCpCodedStringStructT_v02 codewordString;
+  /**<   Codeword string; the encoding method is specified in the
+       qmiLocNiUmtsCpCodedStringStructT.dataCodingScheme field. */
+
+  uint8_t lcsServiceTypeId;
+  /**<   Service type ID. */
+
+  uint16_t userResponseTimer;
+  /**<   Time to wait for the user to respond. \n
+       - Units: Seconds */
+}qmiLocNiUmtsCpNotifyVerifyStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCNISERVICEINTERACTIONENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_NI_SERVICE_INTERACTION_ONGOING_NI_INCOMING_MO_V02 = 1, /**<  Service interaction between ongoing NI and incoming MO sessions.  */
+  QMILOCNISERVICEINTERACTIONENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocNiServiceInteractionEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  qmiLocNiVxNotifyVerifyStructT_v02 niVxReq;
+  /**<   Ongoing NI session request; this information is currently not filled. */
+
+  qmiLocNiServiceInteractionEnumT_v02 serviceInteractionType;
+  /**<   Service interaction type specified in qmiLocNiServiceInteractionEnumT.
+
+ Valid values: \n
+      - eQMI_LOC_NI_SERVICE_INTERACTION_ONGOING_NI_INCOMING_MO (1) --  Service interaction between ongoing NI and incoming MO sessions.
+ */
+}qmiLocNiVxServiceInteractionStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+typedef uint16_t qmiLocNiSuplVer2ExtSupportedNetworksMaskT_v02;
+#define QMI_LOC_SUPL_VER_2_EXT_MASK_SUPPORTED_NETWORK_WLAN_V02 ((qmiLocNiSuplVer2ExtSupportedNetworksMaskT_v02)0x0001) /**<  Denotes that WLAN measurements are allowed as part of location ID
+       and multiple location IDs in the SUPL_POS_INIT message.  */
+#define QMI_LOC_SUPL_VER_2_EXT_MASK_SUPPORTED_NETWORK_GSM_V02 ((qmiLocNiSuplVer2ExtSupportedNetworksMaskT_v02)0x0002) /**<  Denotes that GSM measurements are allowed as part of location ID
+       and multiple location ID in the SUPL_POS_INIT message.  */
+#define QMI_LOC_SUPL_VER_2_EXT_MASK_SUPPORTED_NETWORK_WCDMA_V02 ((qmiLocNiSuplVer2ExtSupportedNetworksMaskT_v02)0x0004) /**<  Denotes that WCDMA measurements are allowed as part of location ID
+       and multiple location ID in the SUPL_POS_INIT message.  */
+#define QMI_LOC_SUPL_VER_2_EXT_MASK_SUPPORTED_NETWORK_CDMA_V02 ((qmiLocNiSuplVer2ExtSupportedNetworksMaskT_v02)0x0008) /**<  Denotes that CDMA measurements are allowed as part of location ID
+       and multiple location ID in the SUPL_POS_INIT message.  */
+#define QMI_LOC_SUPL_VER_2_EXT_MASK_SUPPORTED_NETWORK_HRDP_V02 ((qmiLocNiSuplVer2ExtSupportedNetworksMaskT_v02)0x0010) /**<  Denotes that HRDP measurements are allowed as part of location ID
+       and multiple location ID in the SUPL_POS_INIT message.  */
+#define QMI_LOC_SUPL_VER_2_EXT_MASK_SUPPORTED_NETWORK_UMB_V02 ((qmiLocNiSuplVer2ExtSupportedNetworksMaskT_v02)0x0020) /**<  Denotes that UMB measurements are allowed as part of location ID
+       and multiple location ID in the SUPL_POS_INIT message.  */
+#define QMI_LOC_SUPL_VER_2_EXT_MASK_SUPPORTED_NETWORK_LTE_V02 ((qmiLocNiSuplVer2ExtSupportedNetworksMaskT_v02)0x0040) /**<  Denotes that LTE measurements are allowed as part of location ID
+       and multiple location ID in the SUPL_POS_INIT message.  */
+#define QMI_LOC_SUPL_VER_2_EXT_MASK_SUPPORTED_NETWORK_WIMAX_V02 ((qmiLocNiSuplVer2ExtSupportedNetworksMaskT_v02)0x0080) /**<  Denotes that WIMAX measurements are allowed as part of location ID
+       and multiple location ID in the SUPL_POS_INIT message.  */
+#define QMI_LOC_SUPL_VER_2_EXT_MASK_SUPPORTED_NETWORK_HISTORIC_V02 ((qmiLocNiSuplVer2ExtSupportedNetworksMaskT_v02)0x0100) /**<  Denotes that historical information is allowed as part of
+       multiple location ID in the SUPL_POS_INIT message.  */
+#define QMI_LOC_SUPL_VER_2_EXT_MASK_SUPPORTED_NETWORK_NONSVRV_V02 ((qmiLocNiSuplVer2ExtSupportedNetworksMaskT_v02)0x0200) /**<  Denotes that information about nonserving cells is allowed
+       as part of multiple location ID in the SUPL_POS_INIT message.  */
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCNISUPLVER2EXTTRIGGERTYPEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_SUPL_VER_2_EXT_TRIGGER_TYPE_SINGLE_SHOT_V02 = -1, /**<  SUPL INIT message indicates a request for a single shot
+       triggered session  */
+  eQMI_LOC_SUPL_VER_2_EXT_TRIGGER_TYPE_PERIODIC_V02 = 0, /**<  SUPL INIT message indicates a request for a periodic
+       triggered session  */
+  eQMI_LOC_SUPL_VER_2_EXT_TRIGGER_TYPE_AREA_EVENT_V02 = 1, /**<  SUPL INIT message indicates a request for an area event
+       triggered session  */
+  QMILOCNISUPLVER2EXTTRIGGERTYPEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocNiSuplVer2ExtTriggerTypeEnumT_v02;
+/**
+    @}
+  */
+
+typedef uint16_t qmiLocNiSuplVer2ExtGnssTypeMaskT_v02;
+#define QMI_LOC_SUPL_VER_2_EXT_MASK_GNSS_GPS_V02 ((qmiLocNiSuplVer2ExtGnssTypeMaskT_v02)0x0001) /**<  GPS is allowed to be used as the positioning technology  */
+#define QMI_LOC_SUPL_VER_2_EXT_MASK_GNSS_GLONASS_V02 ((qmiLocNiSuplVer2ExtGnssTypeMaskT_v02)0x0002) /**<  GLONASS is allowed to be used as the positioning technology  */
+#define QMI_LOC_SUPL_VER_2_EXT_MASK_GNSS_GALILEO_V02 ((qmiLocNiSuplVer2ExtGnssTypeMaskT_v02)0x0004) /**<  Galileo is allowed to be used as the positioning technology  */
+#define QMI_LOC_SUPL_VER_2_EXT_MASK_GNSS_SBAS_V02 ((qmiLocNiSuplVer2ExtGnssTypeMaskT_v02)0x0008) /**<  SBAS is allowed to be used as the positioning technology  */
+#define QMI_LOC_SUPL_VER_2_EXT_MASK_GNSS_QZSS_V02 ((qmiLocNiSuplVer2ExtGnssTypeMaskT_v02)0x0010) /**<  QZSS is allowed to be used as the positioning technology  */
+#define QMI_LOC_SUPL_VER_2_EXT_MASK_GNSS_MODERN_GPS_V02 ((qmiLocNiSuplVer2ExtGnssTypeMaskT_v02)0x0020) /**<  Modern GPS is allowed to be used as the positioning technology  */
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  qmiLocNiSuplVer2ExtSupportedNetworksMaskT_v02 supportedNetworksMask;
+  /**<   Specifies which type of network measurements are allowed to be sent as
+       part of the Location ID or Multiple Location IDs parameter in the
+       SUPL_POS_INIT message (refer to 3GPP \hyperref[TS 03.32]{TS 03.32}).
+
+       Valid bitmasks: \begin{itemize1}
+       \item    0x0001 -- SUPPORTED_NETWORK_ WLAN
+       \item    0x0002 -- SUPPORTED_NETWORK_ GSM
+       \item    0x0004 -- SUPPORTED_NETWORK_ WCDMA
+       \item    0x0008 -- SUPPORTED_NETWORK_ CDMA
+       \item    0x0010 -- SUPPORTED_NETWORK_ HRDP
+       \item    0x0020 -- SUPPORTED_NETWORK_ UMB
+       \item    0x0040 -- SUPPORTED_NETWORK_ LTE
+       \item    0x0080 -- SUPPORTED_NETWORK_ WIMAX
+       \item    0x0100 -- SUPPORTED_NETWORK_ HISTORIC
+       \item    0x0200 -- SUPPORTED_NETWORK_ NONSVRV
+       \vspace{-0.18in} \end{itemize1}
+   */
+
+  qmiLocNiSuplVer2ExtTriggerTypeEnumT_v02 triggerType;
+  /**<   Specifies the type of session trigger requested in the
+ SUPL_POS_INIT message (refer to 3GPP \hyperref[TS 03.32]{TS 03.32}).
+
+ Valid values: \n
+      - eQMI_LOC_SUPL_VER_2_EXT_TRIGGER_TYPE_SINGLE_SHOT (-1) --  SUPL INIT message indicates a request for a single shot
+       triggered session
+      - eQMI_LOC_SUPL_VER_2_EXT_TRIGGER_TYPE_PERIODIC (0) --  SUPL INIT message indicates a request for a periodic
+       triggered session
+      - eQMI_LOC_SUPL_VER_2_EXT_TRIGGER_TYPE_AREA_EVENT (1) --  SUPL INIT message indicates a request for an area event
+       triggered session
+ */
+
+  qmiLocNiSuplVer2ExtGnssTypeMaskT_v02 gnssType;
+  /**<   Specifies which GNSS technologies are allowed as positioning
+       technologies.
+
+       Valid bitmasks: \n
+        - 0x0001 -- GNSS_GPS \n
+        - 0x0002 -- GNSS_GLONASS \n
+        - 0x0004 -- GNSS_GALILEO \n
+        - 0x0008 -- GNSS_SBAS \n
+        - 0x0010 -- GNSS_QZSS \n
+        - 0x0020 -- GNSS_MODERN_GPS
+  */
+}qmiLocNiSuplVer2ExtStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  char eslpUrl[QMI_LOC_MAX_SERVER_ADDR_LENGTH_V02 + 1];
+  /**<   ESLP URL. \n
+       Maximum length: 255 bytes */
+}qmiLocEmergencyNotificationStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Indicates an NI Notify/Verify request to the control point. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Notification Type */
+  qmiLocNiNotifyVerifyEnumT_v02 notificationType;
+  /**<   Type of notification/verification performed.
+
+ Valid values: \n
+      - eQMI_LOC_NI_USER_NO_NOTIFY_NO_VERIFY (1) --  No notification and no verification required
+      - eQMI_LOC_NI_USER_NOTIFY_ONLY (2) --  Notify only; no verification required
+      - eQMI_LOC_NI_USER_NOTIFY_VERIFY_ALLOW_NO_RESP (3) --  Notify and verify, but no response required.
+      - eQMI_LOC_NI_USER_NOTIFY_VERIFY_NOT_ALLOW_NO_RESP (4) --  Notify and verify, and require a response
+      - eQMI_LOC_NI_USER_NOTIFY_VERIFY_PRIVACY_OVERRIDE (5) --  Notify and verify; privacy override
+ */
+
+  /* Optional */
+  /*  Network Initiated Vx Request */
+  uint8_t NiVxInd_valid;  /**< Must be set to true if NiVxInd is being passed */
+  qmiLocNiVxNotifyVerifyStructT_v02 NiVxInd;
+  /**<   \vspace{0.06in} \n Optional NI Vx request payload. */
+
+  /* Optional */
+  /*  Network Initiated SUPL Request */
+  uint8_t NiSuplInd_valid;  /**< Must be set to true if NiSuplInd is being passed */
+  qmiLocNiSuplNotifyVerifyStructT_v02 NiSuplInd;
+  /**<   \vspace{0.06in} \n Optional NI SUPL request payload. */
+
+  /* Optional */
+  /*  Network Initiated UMTS Control Plane Request */
+  uint8_t NiUmtsCpInd_valid;  /**< Must be set to true if NiUmtsCpInd is being passed */
+  qmiLocNiUmtsCpNotifyVerifyStructT_v02 NiUmtsCpInd;
+  /**<   \vspace{0.06in} \n Optional NI UMTS-CP request payload. */
+
+  /* Optional */
+  /*  Network Initiated Service Interaction Request */
+  uint8_t NiVxServiceInteractionInd_valid;  /**< Must be set to true if NiVxServiceInteractionInd is being passed */
+  qmiLocNiVxServiceInteractionStructT_v02 NiVxServiceInteractionInd;
+  /**<   \vspace{0.06in} \n Optional NI service interaction payload. */
+
+  /* Optional */
+  /*  Network Initiated SUPL Version 2 Extension */
+  uint8_t NiSuplVer2ExtInd_valid;  /**< Must be set to true if NiSuplVer2ExtInd is being passed */
+  qmiLocNiSuplVer2ExtStructT_v02 NiSuplVer2ExtInd;
+  /**<   \vspace{0.06in} \n Optional NI SUPL Version 2 Extension payload. When present,
+          this payload is to be used in conjunction with the SUPL
+          indication payload. */
+
+  /* Optional */
+  /*  SUPL Emergency Notification */
+  uint8_t suplEmergencyNotification_valid;  /**< Must be set to true if suplEmergencyNotification is being passed */
+  qmiLocEmergencyNotificationStructT_v02 suplEmergencyNotification;
+  /**<   \vspace{0.06in} \n This specifies that the corresponding NI notification is an
+        emergency notification. Emergency notification
+        can be given even without an Emergency SUPL Location Platform (ESLP)
+        address. */
+}qmiLocEventNiNotifyVerifyReqIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  char serverUrl[QMI_LOC_MAX_SERVER_ADDR_LENGTH_V02 + 1];
+  /**<   Assistance server URL.
+       \begin{itemize1}
+       \item    Type: NULL-terminated string
+       \item    Maximum string length (including NULL terminator): 256
+       \vspace{-0.18in} \end{itemize1} */
+}qmiLocAssistanceServerUrlStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint32_t delayThreshold;
+  /**<   The time server is to be skipped if a one-way delay to the server
+       exceeds this threshold. \n
+       - Units: Milliseconds */
+
+  uint32_t timeServerList_len;  /**< Must be set to # of elements in timeServerList */
+  qmiLocAssistanceServerUrlStructT_v02 timeServerList[QMI_LOC_MAX_NTP_SERVERS_V02];
+  /**<   List of Time Server URL's that are recommended by the service for time
+       information, the list is ordered, the client is to use the first
+       server specified in the list as the primary URL to fetch NTP time,
+       the second one as secondary, and so on. \n
+       - Maximum server list items: 3 */
+}qmiLocTimeServerListStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Requests the control point to inject time information. */
+typedef struct {
+
+  /* Optional */
+  /*  Time Server Info */
+  uint8_t timeServerInfo_valid;  /**< Must be set to true if timeServerInfo is being passed */
+  qmiLocTimeServerListStructT_v02 timeServerInfo;
+  /**<   \vspace{0.06in} \n Contains information about the time servers recommended by the
+       location service for NTP time. */
+}qmiLocEventInjectTimeReqIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint32_t maxFileSizeInBytes;
+  /**<   Maximum allowable predicted orbits file size (in bytes). */
+
+  uint32_t maxPartSize;
+  /**<   Maximum allowable predicted orbits file chunk size (in bytes). */
+}qmiLocPredictedOrbitsAllowedSizesStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint32_t serverList_len;  /**< Must be set to # of elements in serverList */
+  qmiLocAssistanceServerUrlStructT_v02 serverList[QMI_LOC_MAX_PREDICTED_ORBITS_SERVERS_V02];
+  /**<   List of predicted orbits URLs. The list is ordered, so the client
+       must use the first server specified in the list as the primary URL
+       from which to download predicted orbits data, the second one as
+       secondary, and so on. \n
+       - Maximum number of servers that can be specified: 3 */
+}qmiLocPredictedOrbitsServerListStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Requests the control point to inject predicted orbits data. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Allowed Sizes */
+  qmiLocPredictedOrbitsAllowedSizesStructT_v02 allowedSizes;
+  /**<   \vspace{0.06in} \n Maximum part and file size allowed to be injected in the engine. */
+
+  /* Optional */
+  /*  Server List */
+  uint8_t serverList_valid;  /**< Must be set to true if serverList is being passed */
+  qmiLocPredictedOrbitsServerListStructT_v02 serverList;
+  /**<   \vspace{0.06in} \n List of servers that can be used by the client to download
+       predicted orbits data. */
+}qmiLocEventInjectPredictedOrbitsReqIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Requests the control point to inject a position. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Latitude */
+  double latitude;
+  /**<   Latitude (specified in WGS84 datum).
+       \begin{itemize1}
+       \item    Type: Floating point
+       \item    Units: Degrees
+       \item    Range: -90.0 to 90.0      \begin{itemize1}
+         \item    Positive values indicate northern latitude
+         \item    Negative values indicate southern latitude
+       \vspace{-0.18in} \end{itemize1} \end{itemize1} */
+
+  /* Mandatory */
+  /*  Longitude */
+  double longitude;
+  /**<   Longitude (specified in WGS84 datum).
+       \begin{itemize1}
+       \item    Type: Floating point
+       \item    Units: Degrees
+       \item    Range: -180.0 to 180.0     \begin{itemize1}
+         \item    Positive values indicate eastern longitude
+         \item    Negative values indicate western longitude
+       \vspace{-0.18in} \end{itemize1} \end{itemize1} */
+
+  /* Mandatory */
+  /*  Circular Horizontal Uncertainty */
+  float horUncCircular;
+  /**<   Horizontal position uncertainty (circular).\n
+       - Units: Meters */
+
+  /* Mandatory */
+  /*  UTC Timestamp */
+  uint64_t timestampUtc;
+  /**<   UTC timestamp.
+       \begin{itemize1}
+       \item    Units: Milliseconds since Jan. 1, 1970
+       \vspace{-0.18in} \end{itemize1} */
+}qmiLocEventInjectPositionReqIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCENGINESTATEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_ENGINE_STATE_ON_V02 = 1, /**<  Location engine is on  */
+  eQMI_LOC_ENGINE_STATE_OFF_V02 = 2, /**<  Location engine is off  */
+  QMILOCENGINESTATEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocEngineStateEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Sends the engine state to the control point. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Engine State */
+  qmiLocEngineStateEnumT_v02 engineState;
+  /**<   Location engine state.
+
+ Valid values: \n
+      - eQMI_LOC_ENGINE_STATE_ON (1) --  Location engine is on
+      - eQMI_LOC_ENGINE_STATE_OFF (2) --  Location engine is off
+ */
+}qmiLocEventEngineStateIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCFIXSESSIONSTATEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_FIX_SESSION_STARTED_V02 = 1, /**<  Location fix session has started  */
+  eQMI_LOC_FIX_SESSION_FINISHED_V02 = 2, /**<  Location fix session has ended  */
+  QMILOCFIXSESSIONSTATEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocFixSessionStateEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Sends the fix session state to the control point. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Session State */
+  qmiLocFixSessionStateEnumT_v02 sessionState;
+  /**<   LOC fix session state.
+
+ Valid values: \n
+      - eQMI_LOC_FIX_SESSION_STARTED (1) --  Location fix session has started
+      - eQMI_LOC_FIX_SESSION_FINISHED (2) --  Location fix session has ended
+ */
+
+  /* Optional */
+  /*  Session ID */
+  uint8_t sessionId_valid;  /**< Must be set to true if sessionId is being passed */
+  uint8_t sessionId;
+  /**<   ID of the session that was specified in the Start request.
+    This may not be specified for a fix session corresponding to
+    a network-initiated request. \n
+    - Range: 0 to 255 */
+}qmiLocEventFixSessionStateIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCWIFIREQUESTENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_WIFI_START_PERIODIC_HI_FREQ_FIXES_V02 = 0, /**<  Start periodic fixes with high frequency  */
+  eQMI_LOC_WIFI_START_PERIODIC_KEEP_WARM_V02 = 1, /**<  Keep warm for low frequency fixes without data downloads  */
+  eQMI_LOC_WIFI_STOP_PERIODIC_FIXES_V02 = 2, /**<  Stop periodic fixes request  */
+  QMILOCWIFIREQUESTENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocWifiRequestEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Sends a Wi-Fi request to the control point. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Request Type */
+  qmiLocWifiRequestEnumT_v02 requestType;
+  /**<   Request type.
+
+ Valid values: \n
+      - eQMI_LOC_WIFI_START_PERIODIC_HI_FREQ_FIXES (0) --  Start periodic fixes with high frequency
+      - eQMI_LOC_WIFI_START_PERIODIC_KEEP_WARM (1) --  Keep warm for low frequency fixes without data downloads
+      - eQMI_LOC_WIFI_STOP_PERIODIC_FIXES (2) --  Stop periodic fixes request
+ */
+
+  /* Optional */
+  /*  Time Between Fixes */
+  uint8_t tbfInMs_valid;  /**< Must be set to true if tbfInMs is being passed */
+  uint16_t tbfInMs;
+  /**<   Time between fixes for a periodic request.\n
+        - Units: Milliseconds */
+
+  /* Optional */
+  /*  E911 Mode */
+  uint8_t e911Mode_valid;  /**< Must be set to true if e911Mode is being passed */
+  uint8_t e911Mode;
+  /**<   Specifies whether GPS engine is in e911 mode when this
+       indication is sent to the client.
+
+       Valid values: \begin{itemize1}
+       \item    0x00 (FALSE) -- GPS engine is not in e911 mode
+       \item    0x01 (TRUE) -- GPS engine is in e911 mode
+       \end{itemize1}
+  */
+}qmiLocEventWifiReqIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint16_t samplesPerBatch;
+  /**<   Specifies the number of samples per batch the GNSS location engine is to
+       receive. The sensor sampling frequency can be computed as follows: \vspace{-0.06in} \n
+
+       samplingFrequency = samplesPerBatch * batchesPerSecond  \vspace{-0.06in} \n
+
+       samplesPerBatch must be a nonzero positive value.
+  */
+
+  uint16_t batchesPerSecond;
+  /**<   Number of sensor-data batches the GNSS location engine is to receive
+       per second. The rate is specified in an integral number of batches per
+       second (Hz).  \vspace{-0.06in} \n
+
+       batchesPerSecond must be a nonzero positive value.
+  */
+}qmiLocSensorControlConfigSamplingSpecStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint8_t injectEnable;
+  /**<   Indicates whether the GNSS location engine is ready to accept data from this
+       sensor.
+
+       Valid values: \begin{itemize1}
+       \item    0x01 (TRUE)  -- GNSS location engine is ready to accept sensor
+                                data
+       \item    0x00 (FALSE) -- GNSS location engine is not ready to accept
+                                sensor data
+        \vspace{-0.18in} \end{itemize1}
+  */
+
+  qmiLocSensorControlConfigSamplingSpecStructT_v02 dataFrequency;
+  /**<   Rate at which the GNSS engine would like the sensor to be sampled. \n
+       The rate is specified in integral number of samples per second (Hz)\n
+       and batches per second.
+  */
+}qmiLocSensorReadyStatusStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Notifies the control point if the GNSS location engine is
+                    ready to accept sensor data. */
+typedef struct {
+
+  /* Optional */
+  /*  Accelerometer Accept Ready */
+  uint8_t accelReady_valid;  /**< Must be set to true if accelReady is being passed */
+  qmiLocSensorReadyStatusStructT_v02 accelReady;
+  /**<   \vspace{0.06in} \n Indicates whether the GNSS location engine is ready
+         to accept accelerometer sensor data.
+   */
+
+  /* Optional */
+  /*  Gyroscope Accept Ready */
+  uint8_t gyroReady_valid;  /**< Must be set to true if gyroReady is being passed */
+  qmiLocSensorReadyStatusStructT_v02 gyroReady;
+  /**<   \vspace{0.06in} \n Indicates whether the GNSS location engine is ready
+         to accept gyroscope sensor data.
+   */
+
+  /* Optional */
+  /*  Accelerometer Temperature Accept Ready */
+  uint8_t accelTemperatureReady_valid;  /**< Must be set to true if accelTemperatureReady is being passed */
+  qmiLocSensorReadyStatusStructT_v02 accelTemperatureReady;
+  /**<   \vspace{0.06in} \n Indicates whether the GNSS location engine is ready
+        to accept accelerometer temperature data.
+   */
+
+  /* Optional */
+  /*  Gyroscope Temperature Accept Ready */
+  uint8_t gyroTemperatureReady_valid;  /**< Must be set to true if gyroTemperatureReady is being passed */
+  qmiLocSensorReadyStatusStructT_v02 gyroTemperatureReady;
+  /**<   \vspace{0.06in} \n Indicates whether the GNSS location engine is ready
+         to accept gyroscope temperature data.
+   */
+
+  /* Optional */
+  /*  Calibrated Magnetometer Accept Ready */
+  uint8_t calibratedMagReady_valid;  /**< Must be set to true if calibratedMagReady is being passed */
+  qmiLocSensorReadyStatusStructT_v02 calibratedMagReady;
+  /**<   \vspace{0.06in} \n Indicates whether the GNSS location engine is ready
+         to accept calibrated magnetometer data.
+   */
+
+  /* Optional */
+  /*  Uncalibrated Magnetometer Accept Ready */
+  uint8_t uncalibratedMagReady_valid;  /**< Must be set to true if uncalibratedMagReady is being passed */
+  qmiLocSensorReadyStatusStructT_v02 uncalibratedMagReady;
+  /**<   \vspace{0.06in} \n Indicates whether the GNSS location engine is ready
+         to accept uncalibrated magnetometer data.
+   */
+}qmiLocEventSensorStreamingReadyStatusIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Notifies the control point to inject time synchronization
+                    data. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Opaque Time Sync Reference Counter */
+  uint32_t refCounter;
+  /**<   This TLV is sent to registered control points. It is sent by
+        the location engine when it needs to synchronize location engine and
+        control point (sensor processor) times.
+        This TLV must be echoed back in the Time Sync Inject request. */
+}qmiLocEventTimeSyncReqIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Requests the control point to enable Stationary Position
+                    Indicator (SPI) streaming reports. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Enable/Disable SPI Requests */
+  uint8_t enable;
+  /**<   Indicates whether the client is to start or stop sending an SPI status stream.
+       \begin{itemize1}
+       \item    0x01 (TRUE)  -- Client is to start sending an SPI status stream
+       \item    0x00 (FALSE) -- Client is to stop sending an SPI status stream
+       \vspace{-0.18in} \end{itemize1}*/
+}qmiLocEventSetSpiStreamingReportIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCWWANTYPEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_WWAN_TYPE_INTERNET_V02 = 0, /**<  Bring up the WWAN type used for an Internet connection  */
+  eQMI_LOC_WWAN_TYPE_AGNSS_V02 = 1, /**<  Bring up the WWAN type used for AGNSS connections  */
+  eQMI_LOC_WWAN_TYPE_AGNSS_EMERGENCY_V02 = 2, /**<  Bring up the WWAN type used for AGNSS Emergency connections  */
+  QMILOCWWANTYPEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocWWANTypeEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCSERVERREQUESTENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_SERVER_REQUEST_OPEN_V02 = 1, /**<  Open a connection to the location server  */
+  eQMI_LOC_SERVER_REQUEST_CLOSE_V02 = 2, /**<  Close a connection to the location server  */
+  QMILOCSERVERREQUESTENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocServerRequestEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Requests the client to open or close a connection
+                    to the assisted GPS location server. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Connection Handle */
+  uint32_t connHandle;
+  /**<   Identifies a connection across Open and Close request events. */
+
+  /* Mandatory */
+  /*  Request Type */
+  qmiLocServerRequestEnumT_v02 requestType;
+  /**<   Open or close a connection to the location server.
+
+ Valid values: \n
+      - eQMI_LOC_SERVER_REQUEST_OPEN (1) --  Open a connection to the location server
+      - eQMI_LOC_SERVER_REQUEST_CLOSE (2) --  Close a connection to the location server
+ */
+
+  /* Mandatory */
+  /*  WWAN Type */
+  qmiLocWWANTypeEnumT_v02 wwanType;
+  /**<   Identifies the WWAN type for this request.
+ Valid values: \n
+      - eQMI_LOC_WWAN_TYPE_INTERNET (0) --  Bring up the WWAN type used for an Internet connection
+      - eQMI_LOC_WWAN_TYPE_AGNSS (1) --  Bring up the WWAN type used for AGNSS connections
+      - eQMI_LOC_WWAN_TYPE_AGNSS_EMERGENCY (2) --  Bring up the WWAN type used for AGNSS Emergency connections
+ */
+}qmiLocEventLocationServerConnectionReqIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCNIGEOFENCEOPERATIONENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_NI_GEOFENCE_ADDED_V02 = 1, /**<  An NI Geofence was added  */
+  eQMI_LOC_NI_GEOFENCE_DELETED_V02 = 2, /**<  An NI Geofence was deleted  */
+  eQMI_LOC_NI_GEOFENCE_EDITED_V02 = 3, /**<  An NI Geofence was edited; the control point can query the
+       Geofence to find the its current state  */
+  QMILOCNIGEOFENCEOPERATIONENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocNiGeofenceOperationEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Informs the control point about
+                    network-initiated Geofences. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Geofence ID */
+  uint32_t geofenceId;
+  /**<   ID of the Geofence for which this
+       notification was generated. */
+
+  /* Mandatory */
+  /*  Operation Type */
+  qmiLocNiGeofenceOperationEnumT_v02 operationType;
+  /**<   Operation for which this notification was generated.
+
+ Valid values: \n
+      - eQMI_LOC_NI_GEOFENCE_ADDED (1) --  An NI Geofence was added
+      - eQMI_LOC_NI_GEOFENCE_DELETED (2) --  An NI Geofence was deleted
+      - eQMI_LOC_NI_GEOFENCE_EDITED (3) --  An NI Geofence was edited; the control point can query the
+       Geofence to find the its current state
+ */
+}qmiLocEventNiGeofenceNotificationIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCGEOFENCEGENALERTENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_GEOFENCE_GEN_ALERT_GNSS_UNAVAILABLE_V02 = 1, /**<  GNSS is unavailable and GNSS position fixes
+       cannot be used to monitor Geofences  */
+  eQMI_LOC_GEOFENCE_GEN_ALERT_GNSS_AVAILABLE_V02 = 2, /**<  GNSS is now available and GNSS postion fixes can
+       be used to monitor Geofences  */
+  eQMI_LOC_GEOFENCE_GEN_ALERT_OOS_V02 = 3, /**<  The engine is out of service and no cell ID coverage
+       information is available  */
+  eQMI_LOC_GEOFENCE_GEN_ALERT_TIME_INVALID_V02 = 4, /**<  The engine has an invalid time  */
+  QMILOCGEOFENCEGENALERTENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocGeofenceGenAlertEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Notifies the control point of the
+                    Geofence status. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Geofence General Alert */
+  qmiLocGeofenceGenAlertEnumT_v02 geofenceAlert;
+  /**<   Specifies the Geofence general alert type.
+
+ Valid values: \n
+      - eQMI_LOC_GEOFENCE_GEN_ALERT_GNSS_UNAVAILABLE (1) --  GNSS is unavailable and GNSS position fixes
+       cannot be used to monitor Geofences
+      - eQMI_LOC_GEOFENCE_GEN_ALERT_GNSS_AVAILABLE (2) --  GNSS is now available and GNSS postion fixes can
+       be used to monitor Geofences
+      - eQMI_LOC_GEOFENCE_GEN_ALERT_OOS (3) --  The engine is out of service and no cell ID coverage
+       information is available
+      - eQMI_LOC_GEOFENCE_GEN_ALERT_TIME_INVALID (4) --  The engine has an invalid time
+ */
+}qmiLocEventGeofenceGenAlertIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCGEOFENCEBREACHTYPEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_GEOFENCE_BREACH_TYPE_ENTERING_V02 = 1, /**<  Denotes that a client entered the Geofence  */
+  eQMI_LOC_GEOFENCE_BREACH_TYPE_LEAVING_V02 = 2, /**<  Denotes that a client left the Geofence  */
+  QMILOCGEOFENCEBREACHTYPEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocGeofenceBreachTypeEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  /*  UTC Timestamp */
+  uint64_t timestampUtc;
+  /**<   UTC timestamp.
+       \begin{itemize1}
+       \item    Units: Milliseconds since Jan. 1, 1970
+       \vspace{-0.18in} \end{itemize1} */
+
+  /*  Latitude */
+  double latitude;
+  /**<   Latitude (specified in WGS84 datum).
+       \begin{itemize1}
+       \item    Type: Floating point
+       \item    Units: Degrees
+       \item    Range: -90.0 to 90.0       \begin{itemize1}
+         \item    Positive values indicate northern latitude
+         \item    Negative values indicate southern latitude
+       \vspace{-0.18in} \end{itemize1} \end{itemize1} */
+
+  /*   Longitude */
+  double longitude;
+  /**<   Longitude (specified in WGS84 datum).
+       \begin{itemize1}
+       \item    Type: Floating point
+       \item    Units: Degrees
+       \item    Range: -180.0 to 180.0     \begin{itemize1}
+         \item    Positive values indicate eastern longitude
+         \item    Negative values indicate western longitude
+       \vspace{-0.18in} \end{itemize1} \end{itemize1} */
+
+  /*  Horizontal Elliptical Uncertainty (Semi-Minor Axis) */
+  float horUncEllipseSemiMinor;
+  /**<   Semi-minor axis of horizontal elliptical uncertainty.\n
+       - Units: Meters */
+
+  /*  Horizontal Elliptical Uncertainty (Semi-Major Axis) */
+  float horUncEllipseSemiMajor;
+  /**<   Semi-major axis of horizontal elliptical uncertainty.\n
+       - Units: Meters */
+
+  /*  Elliptical Horizontal Uncertainty Azimuth */
+  float horUncEllipseOrientAzimuth;
+  /**<   Elliptical horizontal uncertainty azimuth of orientation.\n
+       - Units: Decimal degrees \n
+       - Range: 0 to 180 */
+
+  /*  Horizontal Speed validity bit */
+  uint8_t speedHorizontal_valid;
+  /**<   Indicates whether the Horizontal speed field contains valid
+       information.
+       \begin{itemize1}
+       \item    0x01 (TRUE)  --  Horizontal speed is valid
+       \item    0x00 (FALSE) --  Horizontal speed is invalid
+                                 and is to be ignored
+       \vspace{-0.18in} \end{itemize1} */
+
+  /*  Horizontal Speed */
+  float speedHorizontal;
+  /**<   Horizontal speed.\n
+       - Units: Meters/second */
+
+  /*  Altitude validity bit */
+  uint8_t altitudeWrtEllipsoid_valid;
+  /**<   Indicates whether the altitude field contains valid
+       information.
+       \begin{itemize1}
+       \item    0x01 (TRUE)  --  Altitude field is valid
+       \item    0x00 (FALSE) --  Altitude field is invalid
+                                 and is to be ignored
+       \vspace{-0.18in} \end{itemize1}
+       */
+
+  /*  Altitude With Respect to Ellipsoid */
+  float altitudeWrtEllipsoid;
+  /**<   Altitude with respect to the WGS84 ellipsoid.\n
+       - Units: Meters \n
+       - Range: -500 to 15883 */
+
+  /*  Vertical Uncertainty validity bit */
+  uint8_t vertUnc_valid;
+  /**<   Indicates whether the Vertical Uncertainty field contains valid
+       information.
+       \begin{itemize1}
+       \item    0x01 (TRUE)  --  Vertical Uncertainty field is valid
+       \item    0x00 (FALSE) --  Vertical Uncertainty field is invalid
+                                 and is to be ignored
+       \vspace{-0.18in} \end{itemize1} */
+
+  /*  Vertical Uncertainty */
+  float vertUnc;
+  /**<   Vertical uncertainty.\n
+       - Units: Meters */
+
+  /*  Vertical Speed validity bit */
+  uint8_t speedVertical_valid;
+  /**<   Indicates whether the Vertical Speed field contains valid
+       information.
+       \begin{itemize1}
+       \item    0x01 (TRUE)  --  Vertical Speed field is valid
+       \item    0x00 (FALSE) --  Vertical Speed field is invalid
+                                 and is to be ignored
+       \vspace{-0.18in} \end{itemize1} */
+
+  /*  Vertical Speed */
+  float speedVertical;
+  /**<   Vertical speed.\n
+       - Units: Meters/second */
+
+  /*  heading validity bit */
+  uint8_t heading_valid;
+  /**<   Indicates whether the Heading field contains valid
+       information.
+       \begin{itemize1}
+       \item    0x01 (TRUE)  --  Heading field is valid
+       \item    0x00 (FALSE) --  Heading field is invalid
+                                 and is to be ignored
+       \vspace{-0.18in} \end{itemize1} */
+
+  /*  Heading */
+  float heading;
+  /**<   Heading.\n
+        - Units: Degrees \n
+        - Range: 0 to 359.999  */
+}qmiLocGeofencePositionStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCGEOFENCECONFIDENCEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_GEOFENCE_CONFIDENCE_LOW_V02 = 0x01, /**<  Geofence engine indicates a breach with
+       low confidence; this setting results in lower
+       power usage, and it can impact the yield because
+       incorrect breach events may be sent  */
+  eQMI_LOC_GEOFENCE_CONFIDENCE_MED_V02 = 0x02, /**<  (Default) Geofence engine indicates a breach with
+       medium confidence  */
+  eQMI_LOC_GEOFENCE_CONFIDENCE_HIGH_V02 = 0x03, /**<  Geofence engine indicates a breach with
+       high confidence; this setting results in higher
+       power usage  */
+  QMILOCGEOFENCECONFIDENCEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocGeofenceConfidenceEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Notifies the control point of
+                    a Geofence breach event. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Geofence ID */
+  uint32_t geofenceId;
+  /**<   ID of the Geofence for which this
+       notification was generated. */
+
+  /* Mandatory */
+  /*  Geofence Breach Type */
+  qmiLocGeofenceBreachTypeEnumT_v02 breachType;
+  /**<   The type of breach that generated this event.
+
+ Valid values: \n
+      - eQMI_LOC_GEOFENCE_BREACH_TYPE_ENTERING (1) --  Denotes that a client entered the Geofence
+      - eQMI_LOC_GEOFENCE_BREACH_TYPE_LEAVING (2) --  Denotes that a client left the Geofence
+ */
+
+  /* Optional */
+  /*  Geofence Position */
+  uint8_t geofencePosition_valid;  /**< Must be set to true if geofencePosition is being passed */
+  qmiLocGeofencePositionStructT_v02 geofencePosition;
+  /**<   \vspace{0.06in} \n Position of the client when it breached the Geofence.
+       This TLV is included if the client configures the
+       Geofence to report position. The position is reported
+       at the same confidence level that was specified in the
+       Add Circular Geofence request. */
+
+  /* Optional */
+  /*  Geofence Breach Confidence */
+  uint8_t breachConfidence_valid;  /**< Must be set to true if breachConfidence is being passed */
+  qmiLocGeofenceConfidenceEnumT_v02 breachConfidence;
+  /**<   \vspace{0.06in} \n
+ Given a breach event, the confidence determines the probability
+ that the breach happened at the Geofence boundary.
+ Valid values: \n
+      - eQMI_LOC_GEOFENCE_CONFIDENCE_LOW (0x01) --  Geofence engine indicates a breach with
+       low confidence; this setting results in lower
+       power usage, and it can impact the yield because
+       incorrect breach events may be sent
+      - eQMI_LOC_GEOFENCE_CONFIDENCE_MED (0x02) --  (Default) Geofence engine indicates a breach with
+       medium confidence
+      - eQMI_LOC_GEOFENCE_CONFIDENCE_HIGH (0x03) --  Geofence engine indicates a breach with
+       high confidence; this setting results in higher
+       power usage
+ */
+}qmiLocEventGeofenceBreachIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Recommends how pedometer reports are to be
+                    sent to the location engine. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Request Pedometer Data */
+  uint8_t requestPedometerData;
+  /**<   Indicates whether the GNSS location engine is requesting the client to
+          send pedometer data.
+       \begin{itemize1}
+       \item    0x01 (TRUE)  -- GNSS location engine is requesting
+                                pedometer data
+       \item    0x00 (FALSE) -- GNSS location engine is not requesting
+                                pedometer data
+       \vspace{-0.18in} \end{itemize1}
+  */
+
+  /* Optional */
+  /*  Reset Step Count */
+  uint8_t resetStepCount_valid;  /**< Must be set to true if resetStepCount is being passed */
+  uint8_t resetStepCount;
+  /**<   Indicates whether the location engine is to reset the step count.
+       \begin{itemize1}
+       \item    0x01 (TRUE)  -- Pedometer step count is to be reset
+       \item    0x00 (FALSE) -- Pedometer step count is not to be reset
+       \vspace{-0.18in} \end{itemize1} */
+
+  /* Optional */
+  /*  Step Count Threshold */
+  uint8_t stepCountThreshold_valid;  /**< Must be set to true if stepCountThreshold is being passed */
+  uint32_t stepCountThreshold;
+  /**<   Specifies the number of steps to be sampled in a pedometer report,
+       as recommended by the the location engine. If the threshold is set to 0,
+       the location engine wants a pedometer report at every step event.
+  */
+}qmiLocEventPedometerControlIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Recommends how motion data reports are to be
+                    sent to the location engine. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Request Motion Data */
+  uint8_t requestMotionData;
+  /**<   Indicates whether the GNSS location engine is requesting
+       the client to send motion data.
+       \begin{itemize1}
+       \item    0x01 (TRUE)  -- GNSS location engine is requesting
+                                motion data
+       \item    0x00 (FALSE) -- GNSS location engine is not requesting
+                                motion data
+       \vspace{-0.18in} \end{itemize1}
+  */
+}qmiLocEventMotionDataControlIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  /*  Low Geofence ID */
+  uint32_t idLow;
+  /**<   Contains the starting ID of the Geofence in the range of the continuous
+       range of Geofences that were breached at the same position. */
+
+  /*  High Geofence ID */
+  uint32_t idHigh;
+  /**<   Contains the ending ID of the Geofence in the range of the continuous
+         range of Geofences that were breached at the same position. */
+}qmiLocGeofenceIdContinuousStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Notifies the control point of a Geofence breach event by
+                    batching all the Geofences that were breached. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Geofence Breach Type */
+  qmiLocGeofenceBreachTypeEnumT_v02 breachType;
+  /**<   Type of breach that generated this event.
+
+ Valid values: \n
+      - eQMI_LOC_GEOFENCE_BREACH_TYPE_ENTERING (1) --  Denotes that a client entered the Geofence
+      - eQMI_LOC_GEOFENCE_BREACH_TYPE_LEAVING (2) --  Denotes that a client left the Geofence
+ */
+
+  /* Optional */
+  /*  Geofence ID Continuous */
+  uint8_t geofenceIdContinuousList_valid;  /**< Must be set to true if geofenceIdContinuousList is being passed */
+  uint32_t geofenceIdContinuousList_len;  /**< Must be set to # of elements in geofenceIdContinuousList */
+  qmiLocGeofenceIdContinuousStructT_v02 geofenceIdContinuousList[QMI_LOC_MAX_GEOFENCE_ID_CONTINUOUS_LIST_LENGTH_V02];
+  /**<   \vspace{0.06in} \n Each entry in the list contains the continuous range of Geofence IDs that were breached
+      at the same position. This list does not overlap with the discrete Geofence ID list. */
+
+  /* Optional */
+  /*  Geofence ID Discrete */
+  uint8_t geofenceIdDiscreteList_valid;  /**< Must be set to true if geofenceIdDiscreteList is being passed */
+  uint32_t geofenceIdDiscreteList_len;  /**< Must be set to # of elements in geofenceIdDiscreteList */
+  uint32_t geofenceIdDiscreteList[QMI_LOC_MAX_GEOFENCE_ID_DISCRETE_LIST_LENGTH_V02];
+  /**<   This list contains the Geofence IDs that were breached at the same position.
+       This list does not overlap with the continuous Geofence ID list. */
+
+  /* Optional */
+  /*  Geofence Position */
+  uint8_t geofencePosition_valid;  /**< Must be set to true if geofencePosition is being passed */
+  qmiLocGeofencePositionStructT_v02 geofencePosition;
+  /**<   \vspace{0.06in} \n Position of the client when it breached the Geofence.
+       This TLV is included if the client configures the
+       Geofence to report its position. The position is reported
+       at the same confidence level that was specified in the
+       Add Circular Geofence request. */
+
+  /* Optional */
+  /*  Geofence Breach Confidence */
+  uint8_t breachConfidence_valid;  /**< Must be set to true if breachConfidence is being passed */
+  qmiLocGeofenceConfidenceEnumT_v02 breachConfidence;
+  /**<   \vspace{0.06in} \n
+ Given a breach event, the confidence determines the probability
+ that the breach happened at the Geofence boundary.
+ Valid values: \n
+      - eQMI_LOC_GEOFENCE_CONFIDENCE_LOW (0x01) --  Geofence engine indicates a breach with
+       low confidence; this setting results in lower
+       power usage, and it can impact the yield because
+       incorrect breach events may be sent
+      - eQMI_LOC_GEOFENCE_CONFIDENCE_MED (0x02) --  (Default) Geofence engine indicates a breach with
+       medium confidence
+      - eQMI_LOC_GEOFENCE_CONFIDENCE_HIGH (0x03) --  Geofence engine indicates a breach with
+       high confidence; this setting results in higher
+       power usage
+ */
+
+  /* Optional */
+  /*  Heading Uncertainty */
+  uint8_t headingUnc_valid;  /**< Must be set to true if headingUnc is being passed */
+  float headingUnc;
+  /**<   Heading uncertainty.\n
+       - Units: Degrees \n
+       - Range: 0 to 359.999 */
+
+  /* Optional */
+  /*  Vertical Uncertainty */
+  uint8_t vertUnc_valid;  /**< Must be set to true if vertUnc is being passed */
+  float vertUnc;
+  /**<   Vertical uncertainty.\n
+       - Units: Meters */
+
+  /* Optional */
+  /*  Speed Uncertainty */
+  uint8_t speedUnc_valid;  /**< Must be set to true if speedUnc is being passed */
+  float speedUnc;
+  /**<   3-D speed uncertainty.\n
+       - Units: Meters/second */
+
+  /* Optional */
+  /*  Horizontal Confidence */
+  uint8_t horConfidence_valid;  /**< Must be set to true if horConfidence is being passed */
+  uint8_t horConfidence;
+  /**<   Horizontal uncertainty confidence.\n
+       - Units: Percent \n
+       - Range: 0 to 99 */
+
+  /* Optional */
+  /*  Vertical Confidence */
+  uint8_t vertConfidence_valid;  /**< Must be set to true if vertConfidence is being passed */
+  uint8_t vertConfidence;
+  /**<   Vertical uncertainty confidence.\n
+       - Units: Percent \n
+       - Range: 0 to 99 */
+
+  /* Optional */
+  /*  Dilution of Precision */
+  uint8_t DOP_valid;  /**< Must be set to true if DOP is being passed */
+  qmiLocDOPStructT_v02 DOP;
+  /**<   \vspace{0.06in} \n Dilution of precision associated with this position. */
+
+  /* Optional */
+  /*  SVs Used to Calculate the Fix */
+  uint8_t gnssSvUsedList_valid;  /**< Must be set to true if gnssSvUsedList is being passed */
+  uint32_t gnssSvUsedList_len;  /**< Must be set to # of elements in gnssSvUsedList */
+  uint16_t gnssSvUsedList[QMI_LOC_MAX_SV_USED_LIST_LENGTH_V02];
+  /**<   Each entry in the list contains the SV ID of a satellite
+      used for calculating this position report. The following
+      information is associated with each SV ID: \n
+         Range:    \n
+         - For GPS:     1 to 32 \n
+         - For GLONASS: 65 to 96 \n
+         - For SBAS:    120 to 158 and 183 to 187 \n
+         - For QZSS:    193 to 197 \n
+         - For BDS:     201 to 237 \n
+         - For GAL:     301 to 336
+        */
+}qmiLocEventGeofenceBatchedBreachIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCGEOFENCEPROXIMITYTYPEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_GEOFENCE_PROXIMITY_TYPE_IN_V02 = 1, /**<  Denotes that a client is in proximity of the Geofence \n  */
+  eQMI_LOC_GEOFENCE_PROXIMITY_TYPE_OUT_V02 = 2, /**<  Denotes that a client is out of proximity of the Geofence  */
+  QMILOCGEOFENCEPROXIMITYTYPEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocGeofenceProximityTypeEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Notifies the control point of a Geofence proximity event. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Geofence Breach Type */
+  qmiLocGeofenceProximityTypeEnumT_v02 proximityType;
+  /**<   Valid values: \n
+      - eQMI_LOC_GEOFENCE_PROXIMITY_TYPE_IN (1) --  Denotes that a client is in proximity of the Geofence \n
+      - eQMI_LOC_GEOFENCE_PROXIMITY_TYPE_OUT (2) --  Denotes that a client is out of proximity of the Geofence
+ */
+
+  /* Mandatory */
+  /*  Geofence ID */
+  uint32_t geofenceId;
+  /**<   Identifier of the Geofence that is in proximity to the handset.
+  */
+
+  /* Optional */
+  /*  Geofence Context ID */
+  uint8_t contextId_valid;  /**< Must be set to true if contextId is being passed */
+  uint32_t contextId;
+  /**<    Identifier for the context of the Geofence to which the handset is in proximity.
+        A single Geofence may be associated with different contexts.
+  */
+}qmiLocEventGeofenceProximityIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCGEOFENCEDWELLTYPEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_GEOFENCE_DWELL_TYPE_INSIDE_V02 = 1, /**<  Denotes that a client dwelled inside the Geofence  */
+  eQMI_LOC_GEOFENCE_DWELL_TYPE_OUTSIDE_V02 = 2, /**<  Denotes that a client dwelled outside the Geofence  */
+  QMILOCGEOFENCEDWELLTYPEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocGeofenceDwellTypeEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Notifies the control point of a Geofence dwell event by
+                    batching all the Geofences that were dwelled in. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Geofence Dwell Type */
+  qmiLocGeofenceDwellTypeEnumT_v02 dwellType;
+  /**<   Type of dwell event generated.
+
+ Valid values: \n
+      - eQMI_LOC_GEOFENCE_DWELL_TYPE_INSIDE (1) --  Denotes that a client dwelled inside the Geofence
+      - eQMI_LOC_GEOFENCE_DWELL_TYPE_OUTSIDE (2) --  Denotes that a client dwelled outside the Geofence
+ */
+
+  /* Optional */
+  /*  Geofence ID Continuous */
+  uint8_t geofenceIdContinuousList_valid;  /**< Must be set to true if geofenceIdContinuousList is being passed */
+  uint32_t geofenceIdContinuousList_len;  /**< Must be set to # of elements in geofenceIdContinuousList */
+  qmiLocGeofenceIdContinuousStructT_v02 geofenceIdContinuousList[QMI_LOC_MAX_GEOFENCE_ID_CONTINUOUS_LIST_LENGTH_V02];
+  /**<   Each entry in the list contains the continuous range of Geofence IDs in which a client dwelled.
+       This list does not overlap with the discrete Geofence ID list. */
+
+  /* Optional */
+  /*  Geofence ID Discrete */
+  uint8_t geofenceIdDiscreteList_valid;  /**< Must be set to true if geofenceIdDiscreteList is being passed */
+  uint32_t geofenceIdDiscreteList_len;  /**< Must be set to # of elements in geofenceIdDiscreteList */
+  uint32_t geofenceIdDiscreteList[QMI_LOC_MAX_GEOFENCE_ID_DISCRETE_LIST_LENGTH_V02];
+  /**<   This list contains the Geofence IDs in which a client dwelled.
+       This list does not overlap with the continuous Geofence ID list. */
+
+  /* Optional */
+  /*  Geofence Position */
+  uint8_t geofencePosition_valid;  /**< Must be set to true if geofencePosition is being passed */
+  qmiLocGeofencePositionStructT_v02 geofencePosition;
+  /**<   \n The latest position calculated by the Geofence engine when
+       the dwell notification is sent. */
+
+  /* Optional */
+  /*  Heading Uncertainty */
+  uint8_t headingUnc_valid;  /**< Must be set to true if headingUnc is being passed */
+  float headingUnc;
+  /**<   Heading uncertainty.\n
+       - Units: Degrees \n
+       - Range: 0 to 359.999 */
+
+  /* Optional */
+  /*  Vertical Uncertainty */
+  uint8_t vertUnc_valid;  /**< Must be set to true if vertUnc is being passed */
+  float vertUnc;
+  /**<   Vertical uncertainty.\n
+       - Units: Meters */
+
+  /* Optional */
+  /*  Speed Uncertainty */
+  uint8_t speedUnc_valid;  /**< Must be set to true if speedUnc is being passed */
+  float speedUnc;
+  /**<   3-D speed uncertainty.\n
+       - Units: Meters/second */
+
+  /* Optional */
+  /*  Horizontal Confidence */
+  uint8_t horConfidence_valid;  /**< Must be set to true if horConfidence is being passed */
+  uint8_t horConfidence;
+  /**<   Horizontal uncertainty confidence.\n
+       - Units: Percent \n
+       - Range: 0 to 99 */
+
+  /* Optional */
+  /*  Vertical Confidence */
+  uint8_t vertConfidence_valid;  /**< Must be set to true if vertConfidence is being passed */
+  uint8_t vertConfidence;
+  /**<   Vertical uncertainty confidence.\n
+       - Units: Percent \n
+       - Range: 0 to 99 */
+
+  /* Optional */
+  /*  Dilution of Precision */
+  uint8_t DOP_valid;  /**< Must be set to true if DOP is being passed */
+  qmiLocDOPStructT_v02 DOP;
+  /**<   \vspace{0.06in} \n Dilution of precision associated with this position. */
+
+  /* Optional */
+  /*  SVs Used to Calculate the Fix */
+  uint8_t gnssSvUsedList_valid;  /**< Must be set to true if gnssSvUsedList is being passed */
+  uint32_t gnssSvUsedList_len;  /**< Must be set to # of elements in gnssSvUsedList */
+  uint16_t gnssSvUsedList[QMI_LOC_MAX_SV_USED_LIST_LENGTH_V02];
+  /**<   Each entry in the list contains the SV ID of a satellite
+      used for calculating this position report. The following
+      information is associated with each SV ID: \n
+         Range:    \n
+         - For GPS:     1 to 32 \n
+         - For GLONASS: 65 to 96 \n
+         - For SBAS:    120 to 158 and 183 to 187 \n
+         - For QZSS:    193 to 197 \n
+         - For BDS:     201 to 237 \n
+         - For GAL:     301 to 336
+        */
+}qmiLocEventGeofenceBatchedDwellIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCGDTSERVICEIDENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_GDT_SERVICE_WWAN_V02 = 1, /**<  GDT service for WWAN UL  */
+  eQMI_LOC_GDT_SERVICE_WWAN_DL_V02 = 2, /**<  GDT service for WWAN DL  */
+  QMILOCGDTSERVICEIDENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocGdtServiceIdEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCGDTACCESSSTATUSENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_GDT_ACCESS_ALLOWED_V02 = 1, /**<  GDT access to the service is allowed   */
+  eQMI_LOC_GDT_ACCESS_FAILED_V02 = 2, /**<  Any type of GDT access error   */
+  eQMI_LOC_GDT_ACCESS_NOT_ALLOWED_V02 = 3, /**<  GDT access to the service is not allowed   */
+  QMILOCGDTACCESSSTATUSENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocGdtAccessStatusEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Requests the control point to transfer data. */
+typedef struct {
+
+  /* Mandatory */
+  /*  GDT Service ID */
+  qmiLocGdtServiceIdEnumT_v02 serviceId;
+  /**<   Values: \n
+
+      - eQMI_LOC_GDT_SERVICE_WWAN (1) --  GDT service for WWAN UL
+      - eQMI_LOC_GDT_SERVICE_WWAN_DL (2) --  GDT service for WWAN DL  */
+
+  /* Mandatory */
+  /*  Session ID */
+  uint32_t sessionId;
+  /**<   Session ID. */
+
+  /* Mandatory */
+  /*  Data */
+  uint32_t filePath_len;  /**< Must be set to # of elements in filePath */
+  char filePath[QMI_LOC_MAX_GDT_PATH_LEN_V02];
+  /**<   File path to the data. \n
+         - Type: Array of bytes \n
+         - Maximum length of the array: 255
+    */
+}qmiLocEventGdtUploadBeginStatusReqIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCGDTENDSTATUSENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_GDT_SUCCESS_V02 = 1, /**<  The sent data was accepted   */
+  eQMI_LOC_GDT_FAILED_V02 = 2, /**<  The sent data was not accepted   */
+  eQMI_LOC_GDT_INVALID_V02 = 3, /**<  General error in the received data  */
+  QMILOCGDTENDSTATUSENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocGdtEndStatusEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Requests the control point to report the status of the
+                    transfered data. */
+typedef struct {
+
+  /* Mandatory */
+  /*  GDT Service ID */
+  qmiLocGdtServiceIdEnumT_v02 serviceId;
+  /**<   Values: \n
+
+      - eQMI_LOC_GDT_SERVICE_WWAN (1) --  GDT service for WWAN UL
+      - eQMI_LOC_GDT_SERVICE_WWAN_DL (2) --  GDT service for WWAN DL  */
+
+  /* Mandatory */
+  /*  Session ID */
+  uint32_t sessionId;
+
+  /* Mandatory */
+  /*  GDT End Status */
+  qmiLocGdtEndStatusEnumT_v02 endStatus;
+  /**<   Values: \n
+
+      - eQMI_LOC_GDT_SUCCESS (1) --  The sent data was accepted
+      - eQMI_LOC_GDT_FAILED (2) --  The sent data was not accepted
+      - eQMI_LOC_GDT_INVALID (3) --  General error in the received data  */
+}qmiLocEventGdtUploadEndReqIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+typedef uint32_t qmiLocGdtDownloadReqMaskT_v02;
+#define QMI_LOC_GDT_DOWNLOAD_REQ_MASK_DBH_V02 ((qmiLocGdtDownloadReqMaskT_v02)0x00000001) /**<  Bitmask to specify whether DBH is on or off for the request   */
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Requests the control point to transfer data. */
+typedef struct {
+
+  /* Mandatory */
+  /*  GDT Service ID */
+  qmiLocGdtServiceIdEnumT_v02 serviceId;
+  /**<   Values: \n
+
+      - eQMI_LOC_GDT_SERVICE_WWAN (1) --  GDT service for WWAN UL
+      - eQMI_LOC_GDT_SERVICE_WWAN_DL (2) --  GDT service for WWAN DL  */
+
+  /* Mandatory */
+  /*  Session ID */
+  uint32_t sessionId;
+  /**<   Session ID. */
+
+  /* Mandatory */
+  /*  Interval After Which AP Must Respond to MP */
+  uint32_t respTimeoutInterval;
+  /**<   Interval after which the AP must respond to the MP, in seconds. */
+
+  /* Mandatory */
+  /*  Encoded GTP Client Information */
+  uint32_t clientInfo_len;  /**< Must be set to # of elements in clientInfo */
+  uint8_t clientInfo[QMI_LOC_MAX_GTP_CL_INFO_LEN_V02];
+  /**<   GTP client information encoded in asn.1 format. \n
+         - Type: Array of bytes \n
+         - Maximum length of the array: 1500
+    */
+
+  /* Mandatory */
+  /*  Encoded Mobile Status Data */
+  uint32_t mobileStatusData_len;  /**< Must be set to # of elements in mobileStatusData */
+  uint8_t mobileStatusData[QMI_LOC_MAX_GTP_MSD_LEN_V02];
+  /**<   Mobile status data encoded in asn.1 format. \n
+         - Type: Array of bytes \n
+         - Maximum length of the array: 4000
+    */
+
+  /* Mandatory */
+  /*  Data Filepath (Null terminated) */
+  uint32_t filePath_len;  /**< Must be set to # of elements in filePath */
+  char filePath[QMI_LOC_MAX_GDT_PATH_LEN_V02];
+  /**<   File path to the GTP response data that is applicable to MP. \n
+         - Type: Array of bytes \n
+         - Maximum length of the array: 255
+    */
+
+  /* Optional */
+  /*  Power Budget Info */
+  uint8_t powerBudgetInfo_valid;  /**< Must be set to true if powerBudgetInfo is being passed */
+  uint32_t powerBudgetInfo;
+  /**<   Power budget information. */
+
+  /* Optional */
+  /*  Power Budget Allowance */
+  uint8_t powerBudgetAllowance_valid;  /**< Must be set to true if powerBudgetAllowance is being passed */
+  uint32_t powerBudgetAllowance;
+  /**<   Power budget allowance. */
+
+  /* Optional */
+  /*  Download Request Mask */
+  uint8_t downloadRequestMask_valid;  /**< Must be set to true if downloadRequestMask is being passed */
+  qmiLocGdtDownloadReqMaskT_v02 downloadRequestMask;
+  /**<   Download Request Mask */
+}qmiLocEventGdtDownloadBeginReqIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCGDTRECEIVESTATUSENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_GTP_RCV_STATUS_CONTINUE_V02 = 1, /**<  Indicates that the AP is to continue sending more partitions to the MP   */
+  eQMI_LOC_GTP_RCV_STATUS_DONE_V02 = 2, /**<  Indicates that the AP is to stop sending partitions to the MP  */
+  QMILOCGDTRECEIVESTATUSENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocGdtReceiveStatusEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Notifies the control point after consuming the current data transfer. */
+typedef struct {
+
+  /* Mandatory */
+  /*  GDT Service ID */
+  qmiLocGdtServiceIdEnumT_v02 serviceId;
+  /**<   Values: \n
+
+      - eQMI_LOC_GDT_SERVICE_WWAN (1) --  GDT service for WWAN UL
+      - eQMI_LOC_GDT_SERVICE_WWAN_DL (2) --  GDT service for WWAN DL  */
+
+  /* Mandatory */
+  /*  Session ID */
+  uint32_t sessionId;
+  /**<   Session ID. */
+
+  /* Mandatory */
+  /*  GDT Receive Status */
+  qmiLocGdtReceiveStatusEnumT_v02 status;
+  /**<   Status indicating the continuation or termination of sending to the AP.
+ Valid values: \n
+      - eQMI_LOC_GTP_RCV_STATUS_CONTINUE (1) --  Indicates that the AP is to continue sending more partitions to the MP
+      - eQMI_LOC_GTP_RCV_STATUS_DONE (2) --  Indicates that the AP is to stop sending partitions to the MP
+ */
+}qmiLocEventGdtReceiveDoneIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCSTATUSENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_SUCCESS_V02 = 0, /**<  Request was completed successfully \n  */
+  eQMI_LOC_GENERAL_FAILURE_V02 = 1, /**<  Request failed because of a general failure \n  */
+  eQMI_LOC_UNSUPPORTED_V02 = 2, /**<  Request failed because it is not supported \n  */
+  eQMI_LOC_INVALID_PARAMETER_V02 = 3, /**<  Request failed because it contained invalid parameters \n  */
+  eQMI_LOC_ENGINE_BUSY_V02 = 4, /**<  Request failed because the engine is busy \n  */
+  eQMI_LOC_PHONE_OFFLINE_V02 = 5, /**<  Request failed because the phone is offline \n  */
+  eQMI_LOC_TIMEOUT_V02 = 6, /**<  Request failed because it timed out \n  */
+  eQMI_LOC_CONFIG_NOT_SUPPORTED_V02 = 7, /**<  Request failed because an undefined configuration was requested \n  */
+  eQMI_LOC_INSUFFICIENT_MEMORY_V02 = 8, /**<  Request failed because the engine could not allocate sufficient memory for the request \n  */
+  eQMI_LOC_MAX_GEOFENCE_PROGRAMMED_V02 = 9, /**<  Request failed because the maximum number of Geofences are already programmed \n  */
+  eQMI_LOC_XTRA_VERSION_CHECK_FAILURE_V02 = 10, /**<  Location service failed because of an XTRA version-based file format check failure  */
+  QMILOCSTATUSENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocStatusEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Notifies the control point of the end of a download session. */
+typedef struct {
+
+  /* Mandatory */
+  /*  GDT Service ID */
+  qmiLocGdtServiceIdEnumT_v02 serviceId;
+  /**<   Values: \n
+
+      - eQMI_LOC_GDT_SERVICE_WWAN (1) --  GDT service for WWAN UL
+      - eQMI_LOC_GDT_SERVICE_WWAN_DL (2) --  GDT service for WWAN DL  */
+
+  /* Mandatory */
+  /*  Session ID */
+  uint32_t sessionId;
+  /**<   Session ID. */
+
+  /* Mandatory */
+  /*  GDT Download End Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the download session.
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+}qmiLocEventGdtDownloadEndReqIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Client can query the service revision using this message. */
+typedef struct {
+  /* This element is a placeholder to prevent the declaration of
+     an empty struct.  DO NOT USE THIS FIELD UNDER ANY CIRCUMSTANCE */
+  char __placeholder;
+}qmiLocGetServiceRevisionReqMsgT_v02;
+
+  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Client can query the service revision using this message. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Get Revision Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Get Revision request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Mandatory */
+  /*  Interface Definition Minor Revision */
+  uint32_t revision;
+  /**<   Revision of the service. This is the minor revision of the interface that
+       the service implements. Minor revision updates of the service are always
+       backward compatible. */
+
+  /* Optional */
+  /*  GNSS Measurement Engine Firmware Version String */
+  uint8_t gnssMeFWVerString_valid;  /**< Must be set to true if gnssMeFWVerString is being passed */
+  char gnssMeFWVerString[QMI_LOC_GNSS_ME_VERSION_STRING_MAX_LENGTH_V02 + 1];
+  /**<   Version of the GNSS measurement engine software running under the LOC API.
+       \begin{itemize1}
+       \item    Type: NULL-terminated string
+       \item    Maximum string length (including NULL terminator): 128
+       \vspace{0.1in} \end{itemize1}
+
+       \textbf{Note:} This string is only provided on platforms that have
+       a measurement engine that supports this version string. On all other
+       platforms, this optional TLV is not provided. */
+
+  /* Optional */
+  /*  GNSS Hosted Software Version String */
+  uint8_t gnssHostSWVerString_valid;  /**< Must be set to true if gnssHostSWVerString is being passed */
+  char gnssHostSWVerString[QMI_LOC_GNSS_HOSTED_SW_VERSION_STRING_MAX_LENGTH_V02 + 1];
+  /**<   Version of the GNSS hosted software running under the LOC API.
+       \begin{itemize1}
+       \item    Type: NULL-terminated string
+       \item    Maximum string length (including NULL terminator): 128
+       \vspace{0.1in}\end{itemize1}
+
+       \textbf{Note:} This string is only provided on hosted architectures
+       (measurement and position engine running on different processors) that
+       support this version string. On all other platforms, this optional TLV
+       is not provided. */
+
+  /* Optional */
+  /*  GNSS Software Version String */
+  uint8_t gnssSWVerString_valid;  /**< Must be set to true if gnssSWVerString is being passed */
+  char gnssSWVerString[QMI_LOC_GNSS_SW_VERSION_STRING_MAX_LENGTH_V02 + 1];
+  /**<   Aggregate version of the GNSS software.
+       \begin{itemize1}
+       \item    Type: NULL-terminated string
+       \item    Maximum string length (including NULL terminator): 256
+       \vspace{-0.18in} \end{itemize1} */
+}qmiLocGetServiceRevisionIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Gets the fix criteria from the location engine. */
+typedef struct {
+  /* This element is a placeholder to prevent the declaration of
+     an empty struct.  DO NOT USE THIS FIELD UNDER ANY CIRCUMSTANCE */
+  char __placeholder;
+}qmiLocGetFixCriteriaReqMsgT_v02;
+
+  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Gets the fix criteria from the location engine. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Get Fix Criteria Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Get Fix Criteria request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Optional */
+  /*  Horizontal Accuracy */
+  uint8_t horizontalAccuracyLevel_valid;  /**< Must be set to true if horizontalAccuracyLevel is being passed */
+  qmiLocAccuracyLevelEnumT_v02 horizontalAccuracyLevel;
+  /**<   Horizontal accuracy level.
+
+ Valid values: \n
+      - eQMI_LOC_ACCURACY_LOW (1) --  Low accuracy
+      - eQMI_LOC_ACCURACY_MED (2) --  Medium accuracy
+      - eQMI_LOC_ACCURACY_HIGH (3) --  High accuracy
+ */
+
+  /* Optional */
+  /*  Enable/Disable Intermediate Fixes */
+  uint8_t intermediateReportState_valid;  /**< Must be set to true if intermediateReportState is being passed */
+  qmiLocIntermediateReportStateEnumT_v02 intermediateReportState;
+  /**<   Intermediate Report state (ON, OFF).\n
+ The client must explicitly set this field to OFF to stop receiving
+ intermediate position reports. Intermediate position reports are
+ generated at 1 Hz and are ON by default. If intermediate reports
+ are turned ON, the client receives position reports even if the
+ accuracy criteria is not met. The status in the position report is
+ set to IN_PROGRESS for intermediate reports.
+
+ Valid values: \n
+      - eQMI_LOC_INTERMEDIATE_REPORTS_ON (1) --  Intermediate reports are turned on
+      - eQMI_LOC_INTERMEDIATE_REPORTS_OFF (2) --  Intermediate reports are turned off
+ */
+
+  /* Optional */
+  /*  Minimum Interval Between Fixes */
+  uint8_t minInterval_valid;  /**< Must be set to true if minInterval is being passed */
+  uint32_t minInterval;
+  /**<   Time that must elapse before alerting the client. \n
+       - Units: Milliseconds */
+
+  /* Optional */
+  /*  ID of the Application that Sent the Position Request */
+  uint8_t applicationId_valid;  /**< Must be set to true if applicationId is being passed */
+  qmiLocApplicationIdStructT_v02 applicationId;
+  /**<   \vspace{0.06in} \n Application provider, name, and version.*/
+
+  /* Optional */
+  /*  Configuration for Altitude Assumed Info in GNSS SV Info Event */
+  uint8_t configAltitudeAssumed_valid;  /**< Must be set to true if configAltitudeAssumed is being passed */
+  qmiLocConfigIncludeAltitudeAssumedInGnssSvInfoEnumT_v02 configAltitudeAssumed;
+  /**<   Specifies the configuration to include Altitude Assumed information in the GNSS SV Info Event.
+ When enabled, an additional GNSS SV Info event indication is sent to the control
+ point that also includes the altitude assumed information.
+ If not specified, the configuration defaults to ENABLED.
+ Valid values: \n
+      - eQMI_LOC_ALTITUDE_ASSUMED_IN_GNSS_SV_INFO_ENABLED (1) --  Enable Altitude Assumed information in GNSS SV Info Event.
+      - eQMI_LOC_ALTITUDE_ASSUMED_IN_GNSS_SV_INFO_DISABLED (2) --  Disable Altitude Assumed information in GNSS SV Info Event.
+ */
+
+  /* Optional */
+  /*  Minimum Interval Between Intermediate Position Reports */
+  uint8_t minIntermediatePositionReportInterval_valid;  /**< Must be set to true if minIntermediatePositionReportInterval is being passed */
+  uint32_t minIntermediatePositionReportInterval;
+  /**<   Minimum time interval for intermediate position reports, specified by the control point,
+       that, between the position reports elapsed time, must be longer than the interval time.
+       If this optional value is not set or set to the default value (0), the intermediate position
+       will be reported when it is ready. \n
+       - Units: Milliseconds \n
+       - Default: 0 ms
+  */
+
+  /* Optional */
+  /*  Maximum Wait Time to Get a Position Report */
+  uint8_t positionReportTimeout_valid;  /**< Must be set to true if positionReportTimeout is being passed */
+  uint32_t positionReportTimeout;
+  /**<   Maximum time to work on each fix, specified by the control point.
+       The GPS engine returns QMI_ERR_INTERNAL if a position cannot be obtained
+       within the positionReportTimeout value. \n
+       - Units: Milliseconds \n
+       - Default: 255*1000 ms \n
+       - Range: 1000 - 255*1000 ms
+  */
+
+  /* Optional */
+  /*  Share position report with other clients */
+  uint8_t sharePosition_valid;  /**< Must be set to true if sharePosition is being passed */
+  uint8_t sharePosition;
+  /**<   Allow to share the position report with the other QMI_LOC clients \n
+         \item    0x00(FALSE) Do not share the position report
+         \item    0x01(TRUE)  Share the position report
+        \vspace{-0.18in} \end{itemize1}
+  */
+}qmiLocGetFixCriteriaIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCNIUSERRESPENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_NI_LCS_NOTIFY_VERIFY_ACCEPT_V02 = 1, /**<  User accepted the Notify/Verify request  */
+  eQMI_LOC_NI_LCS_NOTIFY_VERIFY_DENY_V02 = 2, /**<  User denied the Notify/Verify request  */
+  eQMI_LOC_NI_LCS_NOTIFY_VERIFY_NORESP_V02 = 3, /**<  User did not respond to the Notify/Verify request  */
+  QMILOCNIUSERRESPENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocNiUserRespEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Sends the NI user response back to the engine; success or
+                    failure is reported in a separate indication. */
+typedef struct {
+
+  /* Mandatory */
+  /*  User Response */
+  qmiLocNiUserRespEnumT_v02 userResp;
+  /**<   User accepted or denied.
+
+ Valid values: \n
+      - eQMI_LOC_NI_LCS_NOTIFY_VERIFY_ACCEPT (1) --  User accepted the Notify/Verify request
+      - eQMI_LOC_NI_LCS_NOTIFY_VERIFY_DENY (2) --  User denied the Notify/Verify request
+      - eQMI_LOC_NI_LCS_NOTIFY_VERIFY_NORESP (3) --  User did not respond to the Notify/Verify request
+ */
+
+  /* Mandatory */
+  /*  Notification Type */
+  qmiLocNiNotifyVerifyEnumT_v02 notificationType;
+  /**<   Type of notification/verification performed.
+
+ Valid values: \n
+      - eQMI_LOC_NI_USER_NO_NOTIFY_NO_VERIFY (1) --  No notification and no verification required
+      - eQMI_LOC_NI_USER_NOTIFY_ONLY (2) --  Notify only; no verification required
+      - eQMI_LOC_NI_USER_NOTIFY_VERIFY_ALLOW_NO_RESP (3) --  Notify and verify, but no response required.
+      - eQMI_LOC_NI_USER_NOTIFY_VERIFY_NOT_ALLOW_NO_RESP (4) --  Notify and verify, and require a response
+      - eQMI_LOC_NI_USER_NOTIFY_VERIFY_PRIVACY_OVERRIDE (5) --  Notify and verify; privacy override
+ */
+
+  /* Optional */
+  /*  Network Initiated Vx Request */
+  uint8_t NiVxPayload_valid;  /**< Must be set to true if NiVxPayload is being passed */
+  qmiLocNiVxNotifyVerifyStructT_v02 NiVxPayload;
+  /**<   \vspace{0.06in} \n Optional NI VX request payload. */
+
+  /* Optional */
+  /*  Network Initiated SUPL Request */
+  uint8_t NiSuplPayload_valid;  /**< Must be set to true if NiSuplPayload is being passed */
+  qmiLocNiSuplNotifyVerifyStructT_v02 NiSuplPayload;
+  /**<   \vspace{0.06in} \n Optional NI SUPL request payload. */
+
+  /* Optional */
+  /*  Network Initiated UMTS Control Plane Request */
+  uint8_t NiUmtsCpPayload_valid;  /**< Must be set to true if NiUmtsCpPayload is being passed */
+  qmiLocNiUmtsCpNotifyVerifyStructT_v02 NiUmtsCpPayload;
+  /**<   \vspace{0.06in} \n Optional NI UMTS-CP request payload. */
+
+  /* Optional */
+  /*  Network Initiated Service Interaction Request */
+  uint8_t NiVxServiceInteractionPayload_valid;  /**< Must be set to true if NiVxServiceInteractionPayload is being passed */
+  qmiLocNiVxServiceInteractionStructT_v02 NiVxServiceInteractionPayload;
+  /**<   \vspace{0.06in} \n Optional NI service interaction payload. */
+
+  /* Optional */
+  /*  Network Initiated SUPL Version 2 Extension */
+  uint8_t NiSuplVer2ExtPayload_valid;  /**< Must be set to true if NiSuplVer2ExtPayload is being passed */
+  qmiLocNiSuplVer2ExtStructT_v02 NiSuplVer2ExtPayload;
+  /**<   \vspace{0.06in} \n Optional SUPL Version 2 Extension payload. */
+
+  /* Optional */
+  /*  SUPL Emergency Notification */
+  uint8_t suplEmergencyNotification_valid;  /**< Must be set to true if suplEmergencyNotification is being passed */
+  qmiLocEmergencyNotificationStructT_v02 suplEmergencyNotification;
+  /**<    \vspace{0.06in} \n SUPL emergency notification payload. Emergency notification
+        can be given even without an ESLP address */
+}qmiLocNiUserRespReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Sends the NI user response back to the engine; success or
+                    failure is reported in a separate indication. */
+typedef struct {
+
+  /* Mandatory */
+  /*  NI User Response Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the NI User Response request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+}qmiLocNiUserRespIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCPREDICTEDORBITSDATAFORMATENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_PREDICTED_ORBITS_XTRA_V02 = 0, /**<  Default is QCOM-XTRA format.  */
+  QMILOCPREDICTEDORBITSDATAFORMATENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocPredictedOrbitsDataFormatEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Injects predicted orbits data. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Total Size */
+  uint32_t totalSize;
+  /**<   Total size of the predicted orbits data to be injected. \n
+        - Units: Bytes */
+
+  /* Mandatory */
+  /*  Total Parts */
+  uint16_t totalParts;
+  /**<   Total number of parts into which the predicted orbits data is
+        divided. */
+
+  /* Mandatory */
+  /*  Part Number */
+  uint16_t partNum;
+  /**<   Number of the current predicted orbits data part; starts at 1. */
+
+  /* Mandatory */
+  /*  Data */
+  uint32_t partData_len;  /**< Must be set to # of elements in partData */
+  char partData[QMI_LOC_MAX_PREDICTED_ORBITS_PART_LEN_V02];
+  /**<   Predicted orbits data. \n
+         - Type: Array of bytes \n
+         - Maximum length of the array: 1024
+    */
+
+  /* Optional */
+  /*  Format Type */
+  uint8_t formatType_valid;  /**< Must be set to true if formatType is being passed */
+  qmiLocPredictedOrbitsDataFormatEnumT_v02 formatType;
+  /**<   Predicted orbits data format. \n
+ Valid values: \n
+      - eQMI_LOC_PREDICTED_ORBITS_XTRA (0) --  Default is QCOM-XTRA format.
+ */
+}qmiLocInjectPredictedOrbitsDataReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Injects predicted orbits data. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Data Injection Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Data Injection request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Optional */
+  /*  Part Number */
+  uint8_t partNum_valid;  /**< Must be set to true if partNum is being passed */
+  uint16_t partNum;
+  /**<   Number of the predicted orbits data part for which this indication
+      is sent; starts at 1. */
+}qmiLocInjectPredictedOrbitsDataIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Gets the predicted orbits data source. */
+typedef struct {
+  /* This element is a placeholder to prevent the declaration of
+     an empty struct.  DO NOT USE THIS FIELD UNDER ANY CIRCUMSTANCE */
+  char __placeholder;
+}qmiLocGetPredictedOrbitsDataSourceReqMsgT_v02;
+
+  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Gets the predicted orbits data source. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Predicted Orbits Data Source Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the query request for a predicted orbits data source.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Optional */
+  /*  Allowed Sizes */
+  uint8_t allowedSizes_valid;  /**< Must be set to true if allowedSizes is being passed */
+  qmiLocPredictedOrbitsAllowedSizesStructT_v02 allowedSizes;
+  /**<   \n Maximum part and file size allowed to be injected in the engine. */
+
+  /* Optional */
+  /*  Server List */
+  uint8_t serverList_valid;  /**< Must be set to true if serverList is being passed */
+  qmiLocPredictedOrbitsServerListStructT_v02 serverList;
+  /**<   \n List of servers that can be used by the client to download
+       predicted orbits data. */
+}qmiLocGetPredictedOrbitsDataSourceIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Gets the predicted orbits data validity. */
+typedef struct {
+  /* This element is a placeholder to prevent the declaration of
+     an empty struct.  DO NOT USE THIS FIELD UNDER ANY CIRCUMSTANCE */
+  char __placeholder;
+}qmiLocGetPredictedOrbitsDataValidityReqMsgT_v02;
+
+  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint64_t startTimeInUTC;
+  /**<   Predicted orbits data is valid starting from this time. \n
+       - Units: Seconds (since Jan. 1, 1970)
+        */
+
+  uint16_t durationHours;
+  /**<   Duration from the start time for which the data is valid.\n
+       - Units: Hours
+        */
+}qmiLocPredictedOrbitsDataValidityStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Gets the predicted orbits data validity. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Predicted Orbits Data Validity Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the query request for predicted orbits data validity.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Optional */
+  /*  Validity Info */
+  uint8_t validityInfo_valid;  /**< Must be set to true if validityInfo is being passed */
+  qmiLocPredictedOrbitsDataValidityStructT_v02 validityInfo;
+}qmiLocGetPredictedOrbitsDataValidityIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Injects UTC time in the location engine. */
+typedef struct {
+
+  /* Mandatory */
+  /*  UTC Time */
+  uint64_t timeUtc;
+  /**<   UTC time since Jan. 1, 1970.\n
+       - Units: Milliseconds */
+
+  /* Mandatory */
+  /*  Time Uncertainty */
+  uint32_t timeUnc;
+  /**<   Time uncertainty.\n
+       - Units: Milliseconds */
+}qmiLocInjectUtcTimeReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Injects UTC time in the location engine. */
+typedef struct {
+
+  /* Mandatory */
+  /*  UTC Time Injection Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the UTC Time Injection request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+}qmiLocInjectUtcTimeIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCALTSRCENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_ALT_SRC_UNKNOWN_V02 = 0, /**<  Source is unknown  */
+  eQMI_LOC_ALT_SRC_GPS_V02 = 1, /**<  GPS is the source  */
+  eQMI_LOC_ALT_SRC_CELL_ID_V02 = 2, /**<  Cell ID provided the source  */
+  eQMI_LOC_ALT_SRC_ENHANCED_CELL_ID_V02 = 3, /**<  Source is enhanced cell ID  */
+  eQMI_LOC_ALT_SRC_WIFI_V02 = 4, /**<  Wi-Fi is the source  */
+  eQMI_LOC_ALT_SRC_TERRESTRIAL_V02 = 5, /**<  Terrestrial source  */
+  eQMI_LOC_ALT_SRC_TERRESTRIAL_HYBRID_V02 = 6, /**<  Hybrid terrestrial source  */
+  eQMI_LOC_ALT_SRC_ALTITUDE_DATABASE_V02 = 7, /**<  Altitude database is the source  */
+  eQMI_LOC_ALT_SRC_BAROMETRIC_ALTIMETER_V02 = 8, /**<  Barometric altimeter is the source  */
+  eQMI_LOC_ALT_SRC_OTHER_V02 = 9, /**<  Other sources  */
+  QMILOCALTSRCENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocAltSrcEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCALTSRCLINKAGEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_ALT_SRC_LINKAGE_NOT_SPECIFIED_V02 = 0, /**<  Not specified  */
+  eQMI_LOC_ALT_SRC_LINKAGE_FULLY_INTERDEPENDENT_V02 = 1, /**<  Fully interdependent  */
+  eQMI_LOC_ALT_SRC_LINKAGE_DEPENDS_ON_LAT_LONG_V02 = 2, /**<  Depends on latitude and longitude  */
+  eQMI_LOC_ALT_SRC_LINKAGE_FULLY_INDEPENDENT_V02 = 3, /**<  Fully independent  */
+  QMILOCALTSRCLINKAGEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocAltSrcLinkageEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCALTSRCUNCERTAINTYCOVERAGEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_ALT_UNCERTAINTY_NOT_SPECIFIED_V02 = 0, /**<  Not specified  */
+  eQMI_LOC_ALT_UNCERTAINTY_POINT_V02 = 1, /**<  Altitude uncertainty is valid at the injected horizontal
+       position coordinates only  */
+  eQMI_LOC_ALT_UNCERTAINTY_FULL_V02 = 2, /**<  Altitude uncertainty applies to the position of the device
+       regardless of horizontal position (within the horizontal
+       uncertainty region, if provided)  */
+  QMILOCALTSRCUNCERTAINTYCOVERAGEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocAltSrcUncertaintyCoverageEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  qmiLocAltSrcEnumT_v02 source;
+  /**<   Specifies the source of the altitude.
+
+ Valid values: \n
+      - eQMI_LOC_ALT_SRC_UNKNOWN (0) --  Source is unknown
+      - eQMI_LOC_ALT_SRC_GPS (1) --  GPS is the source
+      - eQMI_LOC_ALT_SRC_CELL_ID (2) --  Cell ID provided the source
+      - eQMI_LOC_ALT_SRC_ENHANCED_CELL_ID (3) --  Source is enhanced cell ID
+      - eQMI_LOC_ALT_SRC_WIFI (4) --  Wi-Fi is the source
+      - eQMI_LOC_ALT_SRC_TERRESTRIAL (5) --  Terrestrial source
+      - eQMI_LOC_ALT_SRC_TERRESTRIAL_HYBRID (6) --  Hybrid terrestrial source
+      - eQMI_LOC_ALT_SRC_ALTITUDE_DATABASE (7) --  Altitude database is the source
+      - eQMI_LOC_ALT_SRC_BAROMETRIC_ALTIMETER (8) --  Barometric altimeter is the source
+      - eQMI_LOC_ALT_SRC_OTHER (9) --  Other sources
+ */
+
+  qmiLocAltSrcLinkageEnumT_v02 linkage;
+  /**<   Specifies the dependency between the horizontal and
+ altitude position components.
+
+ Valid values: \n
+      - eQMI_LOC_ALT_SRC_LINKAGE_NOT_SPECIFIED (0) --  Not specified
+      - eQMI_LOC_ALT_SRC_LINKAGE_FULLY_INTERDEPENDENT (1) --  Fully interdependent
+      - eQMI_LOC_ALT_SRC_LINKAGE_DEPENDS_ON_LAT_LONG (2) --  Depends on latitude and longitude
+      - eQMI_LOC_ALT_SRC_LINKAGE_FULLY_INDEPENDENT (3) --  Fully independent
+ */
+
+  qmiLocAltSrcUncertaintyCoverageEnumT_v02 coverage;
+  /**<   Specifies the region of uncertainty.
+
+ Valid values: \n
+      - eQMI_LOC_ALT_UNCERTAINTY_NOT_SPECIFIED (0) --  Not specified
+      - eQMI_LOC_ALT_UNCERTAINTY_POINT (1) --  Altitude uncertainty is valid at the injected horizontal
+       position coordinates only
+      - eQMI_LOC_ALT_UNCERTAINTY_FULL (2) --  Altitude uncertainty applies to the position of the device
+       regardless of horizontal position (within the horizontal
+       uncertainty region, if provided)
+ */
+}qmiLocAltitudeSrcInfoStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCPOSITIONSRCENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_POSITION_SRC_GNSS_V02 = 0, /**<  Position source is GNSS  */
+  eQMI_LOC_POSITION_SRC_CELLID_V02 = 1, /**<  Position source is Cell ID  */
+  eQMI_LOC_POSITION_SRC_ENH_CELLID_V02 = 2, /**<  Position source is Enhanced Cell ID  */
+  eQMI_LOC_POSITION_SRC_WIFI_V02 = 3, /**<  Position source is Wi-Fi  */
+  eQMI_LOC_POSITION_SRC_TERRESTRIAL_V02 = 4, /**<  Position source is Terrestrial  */
+  eQMI_LOC_POSITION_SRC_GNSS_TERRESTRIAL_HYBRID_V02 = 5, /**<  Position source is GNSS Terrestrial Hybrid  */
+  eQMI_LOC_POSITION_SRC_OTHER_V02 = 6, /**<  Other sources  */
+  QMILOCPOSITIONSRCENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocPositionSrcEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Injects a position to the location engine. */
+typedef struct {
+
+  /* Optional */
+  /*  Latitude */
+  uint8_t latitude_valid;  /**< Must be set to true if latitude is being passed */
+  double latitude;
+  /**<   Latitude (specified in WGS84 datum).
+       \begin{itemize1}
+       \item    Type: Floating point
+       \item    Units: Degrees
+       \item    Range: -90.0 to 90.0       \begin{itemize1}
+         \item    Positive values indicate northern latitude
+         \item    Negative values indicate southern latitude
+       \vspace{-0.18in} \end{itemize1} \end{itemize1}
+    */
+
+  /* Optional */
+  /*  Longitude */
+  uint8_t longitude_valid;  /**< Must be set to true if longitude is being passed */
+  double longitude;
+  /**<   Longitude (specified in WGS84 datum).
+       \begin{itemize1}
+       \item    Type: Floating point
+       \item    Units: Degrees
+       \item    Range: -180.0 to 180.0     \begin{itemize1}
+         \item    Positive values indicate eastern longitude
+         \item    Negative values indicate western longitude
+       \vspace{-0.18in} \end{itemize1} \end{itemize1}
+   */
+
+  /* Optional */
+  /*  Circular Horizontal Uncertainty */
+  uint8_t horUncCircular_valid;  /**< Must be set to true if horUncCircular is being passed */
+  float horUncCircular;
+  /**<   Horizontal position uncertainty (circular).\n
+        - Units: Meters */
+
+  /* Optional */
+  /*  Horizontal Confidence */
+  uint8_t horConfidence_valid;  /**< Must be set to true if horConfidence is being passed */
+  uint8_t horConfidence;
+  /**<   Horizontal confidence, as defined by ETSI TS 101 109 (3GPP \hyperref[TS 03.32]{TS 03.32).
+        \begin{itemize1}
+        \item    Units: Percent (1 to 99)
+        \item    0, 101 to 255 -- invalid value
+        \item    If 100 is received, reinterpret to 99
+        \end{itemize1}
+        This field must be specified together with horizontal uncertainty.
+        If not specified when horUncCircular is set, the default value is 50. */
+
+  /* Optional */
+  /*  Horizontal Reliability */
+  uint8_t horReliability_valid;  /**< Must be set to true if horReliability is being passed */
+  qmiLocReliabilityEnumT_v02 horReliability;
+  /**<   Specifies the reliability of the horizontal position.
+
+ Valid values: \n
+      - eQMI_LOC_RELIABILITY_NOT_SET (0) --  Location reliability is not set
+      - eQMI_LOC_RELIABILITY_VERY_LOW (1) --  Location reliability is very low; use it at your own risk
+      - eQMI_LOC_RELIABILITY_LOW (2) --  Location reliability is low; little or no cross-checking is possible
+      - eQMI_LOC_RELIABILITY_MEDIUM (3) --  Location reliability is medium; limited cross-check passed
+      - eQMI_LOC_RELIABILITY_HIGH (4) --  Location reliability is high; strong cross-check passed
+ */
+
+  /* Optional */
+  /*  Altitude With Respect to Ellipsoid */
+  uint8_t altitudeWrtEllipsoid_valid;  /**< Must be set to true if altitudeWrtEllipsoid is being passed */
+  float altitudeWrtEllipsoid;
+  /**<   Altitude with respect to the WGS84 ellipsoid.
+        \begin{itemize1}
+        \item    Units: Meters    \begin{itemize1}
+          \item    Positive = height
+          \item    Negative = depth
+        \vspace{-0.18in} \end{itemize1} \end{itemize1}*/
+
+  /* Optional */
+  /*  Altitude With Respect to Sea Level */
+  uint8_t altitudeWrtMeanSeaLevel_valid;  /**< Must be set to true if altitudeWrtMeanSeaLevel is being passed */
+  float altitudeWrtMeanSeaLevel;
+  /**<   Altitude with respect to mean sea level.\n
+       - Units: Meters */
+
+  /* Optional */
+  /*  Vertical Uncertainty */
+  uint8_t vertUnc_valid;  /**< Must be set to true if vertUnc is being passed */
+  float vertUnc;
+  /**<   Vertical uncertainty. This is mandatory if either altitudeWrtEllipsoid
+        or altitudeWrtMeanSeaLevel is specified.\n
+        - Units: Meters */
+
+  /* Optional */
+  /*  Vertical Confidence */
+  uint8_t vertConfidence_valid;  /**< Must be set to true if vertConfidence is being passed */
+  uint8_t vertConfidence;
+  /**<   Vertical confidence, as defined by  ETSI TS 101 109 (3GPP \hyperref[TS 03.32]{TS 03.32}).
+        \begin{itemize1}
+        \item    Units: Percent (0-99)
+        \item    0 -- invalid value
+        \item    100 to 256 -- not used
+        \item    If 100 is received, reinterpret to 99
+        \end{itemize1}
+        This field must be specified together with the vertical uncertainty.
+        If not specified, the default value will be 50. */
+
+  /* Optional */
+  /*  Vertical Reliability */
+  uint8_t vertReliability_valid;  /**< Must be set to true if vertReliability is being passed */
+  qmiLocReliabilityEnumT_v02 vertReliability;
+  /**<   Specifies the reliability of the vertical position.
+
+ Valid values: \n
+      - eQMI_LOC_RELIABILITY_NOT_SET (0) --  Location reliability is not set
+      - eQMI_LOC_RELIABILITY_VERY_LOW (1) --  Location reliability is very low; use it at your own risk
+      - eQMI_LOC_RELIABILITY_LOW (2) --  Location reliability is low; little or no cross-checking is possible
+      - eQMI_LOC_RELIABILITY_MEDIUM (3) --  Location reliability is medium; limited cross-check passed
+      - eQMI_LOC_RELIABILITY_HIGH (4) --  Location reliability is high; strong cross-check passed
+ */
+
+  /* Optional */
+  /*  Altitude Source Info */
+  uint8_t altSourceInfo_valid;  /**< Must be set to true if altSourceInfo is being passed */
+  qmiLocAltitudeSrcInfoStructT_v02 altSourceInfo;
+  /**<   \vspace{0.06in} \n Specifies information regarding the altitude source. */
+
+  /* Optional */
+  /*  UTC Timestamp */
+  uint8_t timestampUtc_valid;  /**< Must be set to true if timestampUtc is being passed */
+  uint64_t timestampUtc;
+  /**<   UTC timestamp. \n
+        - Units: Milliseconds (since Jan. 1, 1970) */
+
+  /* Optional */
+  /*  Position Age */
+  uint8_t timestampAge_valid;  /**< Must be set to true if timestampAge is being passed */
+  int32_t timestampAge;
+  /**<   Position age, which is an estimate of how long ago this fix was made. \n
+        - Units: Milliseconds */
+
+  /* Optional */
+  /*  Position Source */
+  uint8_t positionSrc_valid;  /**< Must be set to true if positionSrc is being passed */
+  qmiLocPositionSrcEnumT_v02 positionSrc;
+  /**<   Source from which this position was obtained.
+
+ Valid values: \n
+      - eQMI_LOC_POSITION_SRC_GNSS (0) --  Position source is GNSS
+      - eQMI_LOC_POSITION_SRC_CELLID (1) --  Position source is Cell ID
+      - eQMI_LOC_POSITION_SRC_ENH_CELLID (2) --  Position source is Enhanced Cell ID
+      - eQMI_LOC_POSITION_SRC_WIFI (3) --  Position source is Wi-Fi
+      - eQMI_LOC_POSITION_SRC_TERRESTRIAL (4) --  Position source is Terrestrial
+      - eQMI_LOC_POSITION_SRC_GNSS_TERRESTRIAL_HYBRID (5) --  Position source is GNSS Terrestrial Hybrid
+      - eQMI_LOC_POSITION_SRC_OTHER (6) --  Other sources
+
+ If altitude is specified and the altitude source is not specified, the engine
+ assumes that the altitude was obtained using the specified position source. \n
+ If both altitude and altitude source are specified, the engine assumes
+ that only latitude and longitude were obtained using the specified position
+ source.
+ */
+
+  /* Optional */
+  /*  Raw Circular Horizontal Uncertainty */
+  uint8_t rawHorUncCircular_valid;  /**< Must be set to true if rawHorUncCircular is being passed */
+  float rawHorUncCircular;
+  /**<   Horizontal position uncertainty (circular) without any optimization.\n
+        - Units: Meters */
+
+  /* Optional */
+  /*  Raw Horizontal Confidence */
+  uint8_t rawHorConfidence_valid;  /**< Must be set to true if rawHorConfidence is being passed */
+  uint8_t rawHorConfidence;
+  /**<   Horizontal confidence associated with raw horizontal uncertainty,
+        as defined by ETSI TS 101 109 (3GPP \hyperref[TS 03.32]{TS 03.32}).
+        \begin{itemize1}
+        \item    Units: Percent (1 to 99)
+        \item    0, 101 to 255 -- invalid value
+        \item    If 100 is received, reinterpret to 99
+        \end{itemize1}
+        This field must be specified together with raw horizontal uncertainty.
+        If not specified when rawHorUncCircular is set, the default value is 50. */
+
+  /* Optional */
+  /*  Free CPI or On-Demand CPI */
+  uint8_t onDemandCpi_valid;  /**< Must be set to true if onDemandCpi is being passed */
+  uint8_t onDemandCpi;
+  /**<   If this position injection is requested by the modem.
+        Type : boolean
+       Valid values: \begin{itemize1}
+       \item    0x00 (FALSE) -- The position injection was not requested by the modem(Free CPI).
+       \item    0x01 (TRUE) -- The position injection was requested by the modem(On-Demand CPI).
+       \end{itemize1} */
+}qmiLocInjectPositionReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Injects a position to the location engine. */
+typedef struct {
+
+  /* Mandatory */
+  /*  UTC Position Injection Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the UTC Position Injection request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+}qmiLocInjectPositionIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCLOCKENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_LOCK_NONE_V02 = 1, /**<  Do not lock any position sessions  */
+  eQMI_LOC_LOCK_MI_V02 = 2, /**<  Lock mobile-initiated position sessions  */
+  eQMI_LOC_LOCK_MT_V02 = 3, /**<  Lock mobile-terminated position sessions  */
+  eQMI_LOC_LOCK_ALL_V02 = 4, /**<  Lock all position sessions  */
+  QMILOCLOCKENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocLockEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Sets the location engine lock. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Lock Type */
+  qmiLocLockEnumT_v02 lockType;
+  /**<   Type of lock.
+
+ Valid values: \n
+      - eQMI_LOC_LOCK_NONE (1) --  Do not lock any position sessions
+      - eQMI_LOC_LOCK_MI (2) --  Lock mobile-initiated position sessions
+      - eQMI_LOC_LOCK_MT (3) --  Lock mobile-terminated position sessions
+      - eQMI_LOC_LOCK_ALL (4) --  Lock all position sessions
+ */
+}qmiLocSetEngineLockReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Sets the location engine lock. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Set Engine Lock Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Set Engine Lock request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+}qmiLocSetEngineLockIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Gets the location engine lock. */
+typedef struct {
+  /* This element is a placeholder to prevent the declaration of
+     an empty struct.  DO NOT USE THIS FIELD UNDER ANY CIRCUMSTANCE */
+  char __placeholder;
+}qmiLocGetEngineLockReqMsgT_v02;
+
+  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Gets the location engine lock. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Get Engine Lock Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Get Engine Lock request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Optional */
+  /*  Lock Type */
+  uint8_t lockType_valid;  /**< Must be set to true if lockType is being passed */
+  qmiLocLockEnumT_v02 lockType;
+  /**<   Type of lock.
+
+ Valid values: \n
+      - eQMI_LOC_LOCK_NONE (1) --  Do not lock any position sessions
+      - eQMI_LOC_LOCK_MI (2) --  Lock mobile-initiated position sessions
+      - eQMI_LOC_LOCK_MT (3) --  Lock mobile-terminated position sessions
+      - eQMI_LOC_LOCK_ALL (4) --  Lock all position sessions
+ */
+}qmiLocGetEngineLockIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Sets the SBAS configuration. */
+typedef struct {
+
+  /* Mandatory */
+  /*  SBAS Config */
+  uint8_t sbasConfig;
+  /**<   Indicates whether SBAS configuration is enabled.
+       \begin{itemize1}
+       \item    0x01 (TRUE) -- SBAS configuration is enabled
+       \item    0x00 (FALSE) -- SBAS configuration is disabled
+       \vspace{-0.18in} \end{itemize1}*/
+}qmiLocSetSbasConfigReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Sets the SBAS configuration. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Set SBAS Config Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Set SBAS Configuration request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+}qmiLocSetSbasConfigIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Gets the SBAS configuration from the location engine. */
+typedef struct {
+  /* This element is a placeholder to prevent the declaration of
+     an empty struct.  DO NOT USE THIS FIELD UNDER ANY CIRCUMSTANCE */
+  char __placeholder;
+}qmiLocGetSbasConfigReqMsgT_v02;
+
+  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Gets the SBAS configuration from the location engine. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Get SBAS Config Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Get SBAS Configuration request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Optional */
+  /*  SBAS Config */
+  uint8_t sbasConfig_valid;  /**< Must be set to true if sbasConfig is being passed */
+  uint8_t sbasConfig;
+  /**<   Indicates whether SBAS configuration is enabled.
+       \begin{itemize1}
+       \item    0x01 (TRUE) -- SBAS configuration is enabled
+       \item    0x00 (FALSE) -- SBAS configuration is disabled
+       \vspace{-0.18in} \end{itemize1}*/
+}qmiLocGetSbasConfigIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+typedef uint32_t qmiLocNmeaSentenceMaskT_v02;
+#define QMI_LOC_NMEA_MASK_GGA_V02 ((qmiLocNmeaSentenceMaskT_v02)0x00000001) /**<  Enable GGA type  */
+#define QMI_LOC_NMEA_MASK_RMC_V02 ((qmiLocNmeaSentenceMaskT_v02)0x00000002) /**<  Enable RMC type  */
+#define QMI_LOC_NMEA_MASK_GSV_V02 ((qmiLocNmeaSentenceMaskT_v02)0x00000004) /**<  Enable GSV type  */
+#define QMI_LOC_NMEA_MASK_GSA_V02 ((qmiLocNmeaSentenceMaskT_v02)0x00000008) /**<  Enable GSA type  */
+#define QMI_LOC_NMEA_MASK_VTG_V02 ((qmiLocNmeaSentenceMaskT_v02)0x00000010) /**<  Enable VTG type  */
+#define QMI_LOC_NMEA_MASK_PQXFI_V02 ((qmiLocNmeaSentenceMaskT_v02)0x00000020) /**<  Enable PQXFI type  */
+#define QMI_LOC_NMEA_MASK_PSTIS_V02 ((qmiLocNmeaSentenceMaskT_v02)0x00000040) /**<  Enable PSTIS type  */
+#define QMI_LOC_NMEA_MASK_GLGSV_V02 ((qmiLocNmeaSentenceMaskT_v02)0x00000080) /**<  Enable GLGSV type  */
+#define QMI_LOC_NMEA_MASK_GNGSA_V02 ((qmiLocNmeaSentenceMaskT_v02)0x00000100) /**<  Enable GNGSA type  */
+#define QMI_LOC_NMEA_MASK_GNGNS_V02 ((qmiLocNmeaSentenceMaskT_v02)0x00000200) /**<  Enable GNGNS type  */
+#define QMI_LOC_NMEA_MASK_GARMC_V02 ((qmiLocNmeaSentenceMaskT_v02)0x00000400) /**<  Enable GARMC type  */
+#define QMI_LOC_NMEA_MASK_GAGSV_V02 ((qmiLocNmeaSentenceMaskT_v02)0x00000800) /**<  Enable GAGSV type  */
+#define QMI_LOC_NMEA_MASK_GAGSA_V02 ((qmiLocNmeaSentenceMaskT_v02)0x00001000) /**<  Enable GAGSA type  */
+#define QMI_LOC_NMEA_MASK_GAVTG_V02 ((qmiLocNmeaSentenceMaskT_v02)0x00002000) /**<  Enable GAVTG type  */
+#define QMI_LOC_NMEA_MASK_GAGGA_V02 ((qmiLocNmeaSentenceMaskT_v02)0x00004000) /**<  Enable GAGGA type  */
+#define QMI_LOC_NMEA_MASK_PQGSA_V02 ((qmiLocNmeaSentenceMaskT_v02)0x00008000) /**<  Enable PQGSA type  */
+#define QMI_LOC_NMEA_MASK_PQGSV_V02 ((qmiLocNmeaSentenceMaskT_v02)0x00010000) /**<  Enable PQGSV type  */
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Sets the NMEA types. */
+typedef struct {
+
+  /* Mandatory */
+  /*  NMEA Sentence Types */
+  qmiLocNmeaSentenceMaskT_v02 nmeaSentenceType;
+  /**<   Bitmasks of NMEA types to enable.
+
+ Valid bitmasks: \n
+      - QMI_LOC_NMEA_MASK_GGA (0x00000001) --  Enable GGA type
+      - QMI_LOC_NMEA_MASK_RMC (0x00000002) --  Enable RMC type
+      - QMI_LOC_NMEA_MASK_GSV (0x00000004) --  Enable GSV type
+      - QMI_LOC_NMEA_MASK_GSA (0x00000008) --  Enable GSA type
+      - QMI_LOC_NMEA_MASK_VTG (0x00000010) --  Enable VTG type
+      - QMI_LOC_NMEA_MASK_PQXFI (0x00000020) --  Enable PQXFI type
+      - QMI_LOC_NMEA_MASK_PSTIS (0x00000040) --  Enable PSTIS type
+      - QMI_LOC_NMEA_MASK_GLGSV (0x00000080) --  Enable GLGSV type
+      - QMI_LOC_NMEA_MASK_GNGSA (0x00000100) --  Enable GNGSA type
+      - QMI_LOC_NMEA_MASK_GNGNS (0x00000200) --  Enable GNGNS type
+      - QMI_LOC_NMEA_MASK_GARMC (0x00000400) --  Enable GARMC type
+      - QMI_LOC_NMEA_MASK_GAGSV (0x00000800) --  Enable GAGSV type
+      - QMI_LOC_NMEA_MASK_GAGSA (0x00001000) --  Enable GAGSA type
+      - QMI_LOC_NMEA_MASK_GAVTG (0x00002000) --  Enable GAVTG type
+      - QMI_LOC_NMEA_MASK_GAGGA (0x00004000) --  Enable GAGGA type
+      - QMI_LOC_NMEA_MASK_PQGSA (0x00008000) --  Enable PQGSA type
+      - QMI_LOC_NMEA_MASK_PQGSV (0x00010000) --  Enable PQGSV type
+ */
+}qmiLocSetNmeaTypesReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Sets the NMEA types. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Set NMEA Types Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of Set NMEA Types request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+}qmiLocSetNmeaTypesIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Gets the NMEA types from the location engine. */
+typedef struct {
+  /* This element is a placeholder to prevent the declaration of
+     an empty struct.  DO NOT USE THIS FIELD UNDER ANY CIRCUMSTANCE */
+  char __placeholder;
+}qmiLocGetNmeaTypesReqMsgT_v02;
+
+  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Gets the NMEA types from the location engine. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Get NMEA Types Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Get NMEA Types request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Optional */
+  /*  NMEA Sentence Types */
+  uint8_t nmeaSentenceType_valid;  /**< Must be set to true if nmeaSentenceType is being passed */
+  qmiLocNmeaSentenceMaskT_v02 nmeaSentenceType;
+  /**<   NMEA types to enable.
+
+ Valid bitmasks: \n
+      - QMI_LOC_NMEA_MASK_GGA (0x00000001) --  Enable GGA type
+      - QMI_LOC_NMEA_MASK_RMC (0x00000002) --  Enable RMC type
+      - QMI_LOC_NMEA_MASK_GSV (0x00000004) --  Enable GSV type
+      - QMI_LOC_NMEA_MASK_GSA (0x00000008) --  Enable GSA type
+      - QMI_LOC_NMEA_MASK_VTG (0x00000010) --  Enable VTG type
+      - QMI_LOC_NMEA_MASK_PQXFI (0x00000020) --  Enable PQXFI type
+      - QMI_LOC_NMEA_MASK_PSTIS (0x00000040) --  Enable PSTIS type
+      - QMI_LOC_NMEA_MASK_GLGSV (0x00000080) --  Enable GLGSV type
+      - QMI_LOC_NMEA_MASK_GNGSA (0x00000100) --  Enable GNGSA type
+      - QMI_LOC_NMEA_MASK_GNGNS (0x00000200) --  Enable GNGNS type
+      - QMI_LOC_NMEA_MASK_GARMC (0x00000400) --  Enable GARMC type
+      - QMI_LOC_NMEA_MASK_GAGSV (0x00000800) --  Enable GAGSV type
+      - QMI_LOC_NMEA_MASK_GAGSA (0x00001000) --  Enable GAGSA type
+      - QMI_LOC_NMEA_MASK_GAVTG (0x00002000) --  Enable GAVTG type
+      - QMI_LOC_NMEA_MASK_GAGGA (0x00004000) --  Enable GAGGA type
+      - QMI_LOC_NMEA_MASK_PQGSA (0x00008000) --  Enable PQGSA type
+      - QMI_LOC_NMEA_MASK_PQGSV (0x00010000) --  Enable PQGSV type
+ */
+}qmiLocGetNmeaTypesIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Enables/disables Low Power Mode (LPM) configuration. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Enable Low Power Mode */
+  uint8_t lowPowerMode;
+  /**<   Indicates whether to enable Low Power mode:\n
+       - 0x01 (TRUE) -- Enable LPM \n
+       - 0x00 (FALSE) -- Disable LPM */
+}qmiLocSetLowPowerModeReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Enables/disables Low Power Mode (LPM) configuration. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Set LPM Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Set Low Power Mode request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+}qmiLocSetLowPowerModeIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Gets the LPM status from the location engine. */
+typedef struct {
+  /* This element is a placeholder to prevent the declaration of
+     an empty struct.  DO NOT USE THIS FIELD UNDER ANY CIRCUMSTANCE */
+  char __placeholder;
+}qmiLocGetLowPowerModeReqMsgT_v02;
+
+  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Gets the LPM status from the location engine. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Get LPM Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Get LPM request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Optional */
+  /*  Enable/Disable LPM */
+  uint8_t lowPowerMode_valid;  /**< Must be set to true if lowPowerMode is being passed */
+  uint8_t lowPowerMode;
+  /**<   Indicates whether to enable Low Power mode:\n
+       - 0x01 (TRUE) -- Enable LPM \n
+       - 0x00 (FALSE) -- Disable LPM */
+}qmiLocGetLowPowerModeIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCSERVERTYPEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_SERVER_TYPE_CDMA_PDE_V02 = 1, /**<  Server type is CDMA PDE  */
+  eQMI_LOC_SERVER_TYPE_CDMA_MPC_V02 = 2, /**<  Server type is CDMA MPC  */
+  eQMI_LOC_SERVER_TYPE_UMTS_SLP_V02 = 3, /**<  Server type is UMTS SLP  */
+  eQMI_LOC_SERVER_TYPE_CUSTOM_PDE_V02 = 4, /**<  Server type is custom PDE  */
+  QMILOCSERVERTYPEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocServerTypeEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Specifies the A-GPS server type and address. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Server Type */
+  qmiLocServerTypeEnumT_v02 serverType;
+  /**<   Type of server.
+
+ Valid values: \n
+      - eQMI_LOC_SERVER_TYPE_CDMA_PDE (1) --  Server type is CDMA PDE
+      - eQMI_LOC_SERVER_TYPE_CDMA_MPC (2) --  Server type is CDMA MPC
+      - eQMI_LOC_SERVER_TYPE_UMTS_SLP (3) --  Server type is UMTS SLP
+      - eQMI_LOC_SERVER_TYPE_CUSTOM_PDE (4) --  Server type is custom PDE
+ */
+
+  /* Optional */
+  /*  IPv4 Address */
+  uint8_t ipv4Addr_valid;  /**< Must be set to true if ipv4Addr is being passed */
+  qmiLocIpV4AddrStructType_v02 ipv4Addr;
+  /**<   \vspace{0.06in} \n IPv4 address and port. */
+
+  /* Optional */
+  /*  IPv6 Address */
+  uint8_t ipv6Addr_valid;  /**< Must be set to true if ipv6Addr is being passed */
+  qmiLocIpV6AddrStructType_v02 ipv6Addr;
+  /**<   \vspace{0.06in} \n IPv6 address and port. */
+
+  /* Optional */
+  /*  Uniform Resource Locator */
+  uint8_t urlAddr_valid;  /**< Must be set to true if urlAddr is being passed */
+  char urlAddr[QMI_LOC_MAX_SERVER_ADDR_LENGTH_V02 + 1];
+  /**<   URL address.
+       \begin{itemize1}
+       \item    Type: NULL-terminated string
+       \item    Maximum string length (including NULL terminator): 256
+       \vspace{-0.18in} \end{itemize1}
+  */
+}qmiLocSetServerReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Specifies the A-GPS server type and address. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Set Server Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Set Server request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+}qmiLocSetServerIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Gets the location server from the location engine. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Server Type */
+  qmiLocServerTypeEnumT_v02 serverType;
+  /**<   Type of server.
+
+ Valid values: \n
+      - eQMI_LOC_SERVER_TYPE_CDMA_PDE (1) --  Server type is CDMA PDE
+      - eQMI_LOC_SERVER_TYPE_CDMA_MPC (2) --  Server type is CDMA MPC
+      - eQMI_LOC_SERVER_TYPE_UMTS_SLP (3) --  Server type is UMTS SLP
+      - eQMI_LOC_SERVER_TYPE_CUSTOM_PDE (4) --  Server type is custom PDE
+ */
+
+  /* Optional */
+  /*  Server Address Type */
+  uint8_t serverAddrTypeMask_valid;  /**< Must be set to true if serverAddrTypeMask is being passed */
+  qmiLocServerAddrTypeMaskT_v02 serverAddrTypeMask;
+  /**<   Type of address the client wants. If unspecified, the
+       indication will contain all the types of addresses
+       it has for the specified server type.
+
+       Valid bitmasks: \n
+         - 0x01 -- IPv4 \n
+         - 0x02 -- IPv6 \n
+         - 0x04 -- URL
+  */
+}qmiLocGetServerReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Gets the location server from the location engine. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Get Server Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Get Server request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Mandatory */
+  /*  Server Type */
+  qmiLocServerTypeEnumT_v02 serverType;
+  /**<   Type of server.
+
+ Valid values: \n
+      - eQMI_LOC_SERVER_TYPE_CDMA_PDE (1) --  Server type is CDMA PDE
+      - eQMI_LOC_SERVER_TYPE_CDMA_MPC (2) --  Server type is CDMA MPC
+      - eQMI_LOC_SERVER_TYPE_UMTS_SLP (3) --  Server type is UMTS SLP
+      - eQMI_LOC_SERVER_TYPE_CUSTOM_PDE (4) --  Server type is custom PDE
+ */
+
+  /* Optional */
+  /*  IPv4 Address */
+  uint8_t ipv4Addr_valid;  /**< Must be set to true if ipv4Addr is being passed */
+  qmiLocIpV4AddrStructType_v02 ipv4Addr;
+  /**<   \vspace{0.06in} \n IPv4 address and port. */
+
+  /* Optional */
+  /*  IPv6 Address */
+  uint8_t ipv6Addr_valid;  /**< Must be set to true if ipv6Addr is being passed */
+  qmiLocIpV6AddrStructType_v02 ipv6Addr;
+  /**<   \vspace{0.06in} \n IPv6 address and port. */
+
+  /* Optional */
+  /*  Uniform Resource Locator */
+  uint8_t urlAddr_valid;  /**< Must be set to true if urlAddr is being passed */
+  char urlAddr[QMI_LOC_MAX_SERVER_ADDR_LENGTH_V02 + 1];
+  /**<   URL.
+       \begin{itemize1}
+       \item    Type: NULL-terminated string
+       \item    Maximum string length (including NULL terminator): 256
+       \vspace{-0.18in} \end{itemize1}
+  */
+}qmiLocGetServerIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+typedef uint64_t qmiLocDeleteGnssDataMaskT_v02;
+#define QMI_LOC_MASK_DELETE_GPS_SVDIR_V02 ((qmiLocDeleteGnssDataMaskT_v02)0x00000001ull) /**<  Mask to delete GPS SVDIR  */
+#define QMI_LOC_MASK_DELETE_GPS_SVSTEER_V02 ((qmiLocDeleteGnssDataMaskT_v02)0x00000002ull) /**<  Mask to delete GPS SVSTEER  */
+#define QMI_LOC_MASK_DELETE_GPS_TIME_V02 ((qmiLocDeleteGnssDataMaskT_v02)0x00000004ull) /**<  Mask to delete GPS time  */
+#define QMI_LOC_MASK_DELETE_GPS_ALM_CORR_V02 ((qmiLocDeleteGnssDataMaskT_v02)0x00000008ull) /**<  Mask to delete almanac correlation  */
+#define QMI_LOC_MASK_DELETE_GLO_SVDIR_V02 ((qmiLocDeleteGnssDataMaskT_v02)0x00000010ull) /**<  Mask to delete GLONASS SVDIR  */
+#define QMI_LOC_MASK_DELETE_GLO_SVSTEER_V02 ((qmiLocDeleteGnssDataMaskT_v02)0x00000020ull) /**<  Mask to delete GLONASS SVSTEER  */
+#define QMI_LOC_MASK_DELETE_GLO_TIME_V02 ((qmiLocDeleteGnssDataMaskT_v02)0x00000040ull) /**<  Mask to delete GLONASS time  */
+#define QMI_LOC_MASK_DELETE_GLO_ALM_CORR_V02 ((qmiLocDeleteGnssDataMaskT_v02)0x00000080ull) /**<  Mask to delete GLONASS almanac correlation  */
+#define QMI_LOC_MASK_DELETE_SBAS_SVDIR_V02 ((qmiLocDeleteGnssDataMaskT_v02)0x00000100ull) /**<  Mask to delete SBAS SVDIR  */
+#define QMI_LOC_MASK_DELETE_SBAS_SVSTEER_V02 ((qmiLocDeleteGnssDataMaskT_v02)0x00000200ull) /**<  Mask to delete SBAS SVSTEER  */
+#define QMI_LOC_MASK_DELETE_POSITION_V02 ((qmiLocDeleteGnssDataMaskT_v02)0x00000400ull) /**<  Mask to delete position estimate  */
+#define QMI_LOC_MASK_DELETE_TIME_V02 ((qmiLocDeleteGnssDataMaskT_v02)0x00000800ull) /**<  Mask to delete time estimate  */
+#define QMI_LOC_MASK_DELETE_IONO_V02 ((qmiLocDeleteGnssDataMaskT_v02)0x00001000ull) /**<  Mask to delete IONO  */
+#define QMI_LOC_MASK_DELETE_UTC_V02 ((qmiLocDeleteGnssDataMaskT_v02)0x00002000ull) /**<  Mask to delete UTC estimate  */
+#define QMI_LOC_MASK_DELETE_HEALTH_V02 ((qmiLocDeleteGnssDataMaskT_v02)0x00004000ull) /**<  Mask to delete SV health record  */
+#define QMI_LOC_MASK_DELETE_SADATA_V02 ((qmiLocDeleteGnssDataMaskT_v02)0x00008000ull) /**<  Mask to delete SADATA  */
+#define QMI_LOC_MASK_DELETE_RTI_V02 ((qmiLocDeleteGnssDataMaskT_v02)0x00010000ull) /**<  Mask to delete RTI  */
+#define QMI_LOC_MASK_DELETE_SV_NO_EXIST_V02 ((qmiLocDeleteGnssDataMaskT_v02)0x00020000ull) /**<  Mask to delete SV_NO_EXIST  */
+#define QMI_LOC_MASK_DELETE_FREQ_BIAS_EST_V02 ((qmiLocDeleteGnssDataMaskT_v02)0x00040000ull) /**<  Mask to delete frequency bias estimate  */
+#define QMI_LOC_MASK_DELETE_BDS_SVDIR_V02 ((qmiLocDeleteGnssDataMaskT_v02)0x00080000ull) /**<  Mask to delete BDS SVDIR  */
+#define QMI_LOC_MASK_DELETE_BDS_SVSTEER_V02 ((qmiLocDeleteGnssDataMaskT_v02)0x00100000ull) /**<  Mask to delete BDS SVSTEER  */
+#define QMI_LOC_MASK_DELETE_BDS_TIME_V02 ((qmiLocDeleteGnssDataMaskT_v02)0x00200000ull) /**<  Mask to delete BDS time  */
+#define QMI_LOC_MASK_DELETE_BDS_ALM_CORR_V02 ((qmiLocDeleteGnssDataMaskT_v02)0x00400000ull) /**<  Mask to delete BDS almanac correlation  */
+#define QMI_LOC_MASK_DELETE_GNSS_SV_BLACKLIST_GPS_V02 ((qmiLocDeleteGnssDataMaskT_v02)0x00800000ull) /**<  Mask to delete GNSS SV blacklist GPS   */
+#define QMI_LOC_MASK_DELETE_GNSS_SV_BLACKLIST_GLO_V02 ((qmiLocDeleteGnssDataMaskT_v02)0x01000000ull) /**<  Mask to delete GNSS SV blacklist GLO   */
+#define QMI_LOC_MASK_DELETE_GNSS_SV_BLACKLIST_BDS_V02 ((qmiLocDeleteGnssDataMaskT_v02)0x02000000ull) /**<  Mask to delete GNSS SV blacklist BDS   */
+#define QMI_LOC_MASK_DELETE_GNSS_SV_BLACKLIST_GAL_V02 ((qmiLocDeleteGnssDataMaskT_v02)0x04000000ull) /**<  Mask to delete GNSS SV blacklist GAL   */
+#define QMI_LOC_MASK_DELETE_GAL_SVDIR_V02 ((qmiLocDeleteGnssDataMaskT_v02)0x08000000ull) /**<  Mask to delete GAL SVDIR  */
+#define QMI_LOC_MASK_DELETE_GAL_SVSTEER_V02 ((qmiLocDeleteGnssDataMaskT_v02)0x10000000ull) /**<  Mask to delete GAL SVSTEER  */
+#define QMI_LOC_MASK_DELETE_GAL_TIME_V02 ((qmiLocDeleteGnssDataMaskT_v02)0x20000000ull) /**<  Mask to delete GAL time  */
+#define QMI_LOC_MASK_DELETE_GAL_ALM_CORR_V02 ((qmiLocDeleteGnssDataMaskT_v02)0x40000000ull) /**<  Mask to delete GAL almanac correlation  */
+typedef uint32_t qmiLocDeleteCelldbDataMaskT_v02;
+#define QMI_LOC_MASK_DELETE_CELLDB_POS_V02 ((qmiLocDeleteCelldbDataMaskT_v02)0x00000001) /**<  Mask to delete cell database position  */
+#define QMI_LOC_MASK_DELETE_CELLDB_LATEST_GPS_POS_V02 ((qmiLocDeleteCelldbDataMaskT_v02)0x00000002) /**<  Mask to delete cell database latest GPS position  */
+#define QMI_LOC_MASK_DELETE_CELLDB_OTA_POS_V02 ((qmiLocDeleteCelldbDataMaskT_v02)0x00000004) /**<  Mask to delete cell database OTA position  */
+#define QMI_LOC_MASK_DELETE_CELLDB_EXT_REF_POS_V02 ((qmiLocDeleteCelldbDataMaskT_v02)0x00000008) /**<  Mask to delete cell database external reference position  */
+#define QMI_LOC_MASK_DELETE_CELLDB_TIMETAG_V02 ((qmiLocDeleteCelldbDataMaskT_v02)0x00000010) /**<  Mask to delete cell database time tag  */
+#define QMI_LOC_MASK_DELETE_CELLDB_CELLID_V02 ((qmiLocDeleteCelldbDataMaskT_v02)0x00000020) /**<  Mask to delete cell database cell ID  */
+#define QMI_LOC_MASK_DELETE_CELLDB_CACHED_CELLID_V02 ((qmiLocDeleteCelldbDataMaskT_v02)0x00000040) /**<  Mask to delete cell database cached cell ID  */
+#define QMI_LOC_MASK_DELETE_CELLDB_LAST_SRV_CELL_V02 ((qmiLocDeleteCelldbDataMaskT_v02)0x00000080) /**<  Mask to delete cell database last service cell  */
+#define QMI_LOC_MASK_DELETE_CELLDB_CUR_SRV_CELL_V02 ((qmiLocDeleteCelldbDataMaskT_v02)0x00000100) /**<  Mask to delete cell database current service cell  */
+#define QMI_LOC_MASK_DELETE_CELLDB_NEIGHBOR_INFO_V02 ((qmiLocDeleteCelldbDataMaskT_v02)0x00000200) /**<  Mask to delete cell database neighbor information  */
+typedef uint32_t qmiLocDeleteClockInfoMaskT_v02;
+#define QMI_LOC_MASK_DELETE_CLOCK_INFO_TIME_EST_V02 ((qmiLocDeleteClockInfoMaskT_v02)0x00000001) /**<  Mask to delete time estimate from clock information  */
+#define QMI_LOC_MASK_DELETE_CLOCK_INFO_FREQ_EST_V02 ((qmiLocDeleteClockInfoMaskT_v02)0x00000002) /**<  Mask to delete frequency estimate from clock information  */
+#define QMI_LOC_MASK_DELETE_CLOCK_INFO_WEEK_NUMBER_V02 ((qmiLocDeleteClockInfoMaskT_v02)0x00000004) /**<  Mask to delete week number from clock information  */
+#define QMI_LOC_MASK_DELETE_CLOCK_INFO_RTC_TIME_V02 ((qmiLocDeleteClockInfoMaskT_v02)0x00000008) /**<  Mask to delete RTC time from clock information  */
+#define QMI_LOC_MASK_DELETE_CLOCK_INFO_TIME_TRANSFER_V02 ((qmiLocDeleteClockInfoMaskT_v02)0x00000010) /**<  Mask to delete time transfer from clock information  */
+#define QMI_LOC_MASK_DELETE_CLOCK_INFO_GPSTIME_EST_V02 ((qmiLocDeleteClockInfoMaskT_v02)0x00000020) /**<  Mask to delete GPS time estimate from clock information  */
+#define QMI_LOC_MASK_DELETE_CLOCK_INFO_GLOTIME_EST_V02 ((qmiLocDeleteClockInfoMaskT_v02)0x00000040) /**<  Mask to delete GLONASS time estimate from clock information  */
+#define QMI_LOC_MASK_DELETE_CLOCK_INFO_GLODAY_NUMBER_V02 ((qmiLocDeleteClockInfoMaskT_v02)0x00000080) /**<  Mask to delete GLONASS day number from clock information  */
+#define QMI_LOC_MASK_DELETE_CLOCK_INFO_GLO4YEAR_NUMBER_V02 ((qmiLocDeleteClockInfoMaskT_v02)0x00000100) /**<  Mask to delete GLONASS four year number from clock information  */
+#define QMI_LOC_MASK_DELETE_CLOCK_INFO_GLO_RF_GRP_DELAY_V02 ((qmiLocDeleteClockInfoMaskT_v02)0x00000200) /**<  Mask to delete GLONASS RF GRP delay from clock information  */
+#define QMI_LOC_MASK_DELETE_CLOCK_INFO_DISABLE_TT_V02 ((qmiLocDeleteClockInfoMaskT_v02)0x00000400) /**<  Mask to delete disable TT from clock information  */
+#define QMI_LOC_MASK_DELETE_CLOCK_INFO_GG_LEAPSEC_V02 ((qmiLocDeleteClockInfoMaskT_v02)0x00000800) /**<  Mask to delete a BDS time estimate from the clock information  */
+#define QMI_LOC_MASK_DELETE_CLOCK_INFO_GG_GGTB_V02 ((qmiLocDeleteClockInfoMaskT_v02)0x00001000) /**<  Mask to delete a BDS time estimate from the clock information  */
+#define QMI_LOC_MASK_DELETE_CLOCK_INFO_BDSTIME_EST_V02 ((qmiLocDeleteClockInfoMaskT_v02)0x00002000) /**<  Mask to delete a BDS time estimate from the clock information  */
+#define QMI_LOC_MASK_DELETE_CLOCK_INFO_GB_GBTB_V02 ((qmiLocDeleteClockInfoMaskT_v02)0x00004000) /**<  Mask to delete Glonass-to-BDS time bias-related information from the
+      clock information  */
+#define QMI_LOC_MASK_DELETE_CLOCK_INFO_BG_BGTB_V02 ((qmiLocDeleteClockInfoMaskT_v02)0x00008000) /**<  Mask to delete BDS-to-GLONASS time bias-related information from the
+       clock information  */
+#define QMI_LOC_MASK_DELETE_CLOCK_INFO_BDSWEEK_NUMBER_V02 ((qmiLocDeleteClockInfoMaskT_v02)0x00010000) /**<  Mask to delete the BDS week number from the clock information  */
+#define QMI_LOC_MASK_DELETE_CLOCK_INFO_BDS_RF_GRP_DELAY_V02 ((qmiLocDeleteClockInfoMaskT_v02)0x00020000) /**<  Mask to delete the BDS RF GRP delay from the clock information  */
+#define QMI_LOC_MASK_DELETE_CLOCK_INFO_GALTIME_EST_V02 ((qmiLocDeleteClockInfoMaskT_v02)0x00040000) /**<  Mask to delete a GAL time estimate from the clock information  */
+#define QMI_LOC_MASK_DELETE_CLOCK_INFO_GALTOGPS_TB_V02 ((qmiLocDeleteClockInfoMaskT_v02)0x00080000) /**<  Mask to delete GAL-to-GPS time bias-related information from the
+      clock information  */
+#define QMI_LOC_MASK_DELETE_CLOCK_INFO_GALTOGLO_TB_V02 ((qmiLocDeleteClockInfoMaskT_v02)0x00100000) /**<  Mask to delete GAL-to-GLO time bias-related information from the
+      clock information  */
+#define QMI_LOC_MASK_DELETE_CLOCK_INFO_GALTOBDS_TB_V02 ((qmiLocDeleteClockInfoMaskT_v02)0x00200000) /**<  Mask to delete GAL-to-BDS time bias-related information from the
+      clock information  */
+#define QMI_LOC_MASK_DELETE_CLOCK_INFO_GALWEEK_NUMBER_V02 ((qmiLocDeleteClockInfoMaskT_v02)0x00800000) /**<  Mask to delete the GAL week number from the clock information  */
+#define QMI_LOC_MASK_DELETE_CLOCK_INFO_GAL_RF_GRP_DELAY_V02 ((qmiLocDeleteClockInfoMaskT_v02)0x01000000) /**<  Mask to delete the GAL RF GRP delay from the clock information  */
+typedef uint8_t qmiLocDeleteSvInfoMaskT_v02;
+#define QMI_LOC_MASK_DELETE_EPHEMERIS_V02 ((qmiLocDeleteSvInfoMaskT_v02)0x01) /**<  Delete ephemeris for the satellite  */
+#define QMI_LOC_MASK_DELETE_ALMANAC_V02 ((qmiLocDeleteSvInfoMaskT_v02)0x02) /**<  Delete almanac for the satellite  */
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint16_t gnssSvId;
+  /**<   SV ID of the satellite whose data is to be deleted.
+       \begin{itemize1}
+       \item    Range:    \begin{itemize1}
+         \item    For GPS:     1 to 32
+         \item    For SBAS:    33 to 64
+         \item    For GLONASS: 65 to 96
+       \vspace{-0.18in} \end{itemize1} \end{itemize1} */
+
+  qmiLocSvSystemEnumT_v02 system;
+  /**<   Indicates to which constellation this SV belongs.
+
+ Valid values: \n
+      - eQMI_LOC_SV_SYSTEM_GPS (1) --  GPS satellite
+      - eQMI_LOC_SV_SYSTEM_GALILEO (2) --  GALILEO satellite
+      - eQMI_LOC_SV_SYSTEM_SBAS (3) --  SBAS satellite
+      - eQMI_LOC_SV_SYSTEM_COMPASS (4) --  COMPASS satellite (Deprecated)
+      - eQMI_LOC_SV_SYSTEM_GLONASS (5) --  GLONASS satellite
+      - eQMI_LOC_SV_SYSTEM_BDS (6) --  BDS satellite
+      - eQMI_LOC_SV_SYSTEM_QZSS (7) --  QZSS satellite
+ */
+
+  qmiLocDeleteSvInfoMaskT_v02 deleteSvInfoMask;
+  /**<   Indicates whether the ephemeris or almanac for a satellite
+ is to be deleted. \n
+ Valid values: \n
+      - QMI_LOC_MASK_DELETE_EPHEMERIS (0x01) --  Delete ephemeris for the satellite
+      - QMI_LOC_MASK_DELETE_ALMANAC (0x02) --  Delete almanac for the satellite
+ */
+}qmiLocDeleteSvInfoStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint16_t gnssSvId;
+  /**<   SV ID of the satellite whose data is to be deleted. \n
+       Range for BDS:     201 to 237 */
+
+  qmiLocDeleteSvInfoMaskT_v02 deleteSvInfoMask;
+  /**<   Indicates if the ephemeris or almanac for a satellite
+ is to be deleted. \n
+ Valid values: \n
+      - QMI_LOC_MASK_DELETE_EPHEMERIS (0x01) --  Delete ephemeris for the satellite
+      - QMI_LOC_MASK_DELETE_ALMANAC (0x02) --  Delete almanac for the satellite
+ */
+}qmiLocDeleteBDSSvInfoStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint16_t gnssSvId;
+  /**<   SV ID of the satellite whose data is to be deleted. \n
+       Range for GAL:     301 to 336 */
+
+  qmiLocDeleteSvInfoMaskT_v02 deleteSvInfoMask;
+  /**<   Indicates if the ephemeris or almanac for a satellite
+ is to be deleted. \n
+ Valid values: \n
+      - QMI_LOC_MASK_DELETE_EPHEMERIS (0x01) --  Delete ephemeris for the satellite
+      - QMI_LOC_MASK_DELETE_ALMANAC (0x02) --  Delete almanac for the satellite
+ */
+}qmiLocDeleteGALSvInfoStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; This command is used to delete the location engine
+                    assistance data. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Delete All */
+  uint8_t deleteAllFlag;
+  /**<   Indicates whether all assistance data is to be deleted.
+
+       Valid values: \begin{itemize1}
+       \item    0x01 (TRUE)  -- All assistance data is to be deleted; if
+                                this flag is set, all the other information
+                         contained in the optional fields for this
+                                message are ignored
+       \item    0x00 (FALSE) -- The optional fields in the message are to be
+                                used to determine which data is to be deleted
+       \vspace{-0.18in} \end{itemize1} */
+
+  /* Optional */
+  /*  Delete SV Info */
+  uint8_t deleteSvInfoList_valid;  /**< Must be set to true if deleteSvInfoList is being passed */
+  uint32_t deleteSvInfoList_len;  /**< Must be set to # of elements in deleteSvInfoList */
+  qmiLocDeleteSvInfoStructT_v02 deleteSvInfoList[QMI_LOC_DELETE_MAX_SV_INFO_LENGTH_V02];
+  /**<   \vspace{0.06in} \n List of satellites for which the assistance data is to be deleted.
+  */
+
+  /* Optional */
+  /*  Delete GNSS Data */
+  uint8_t deleteGnssDataMask_valid;  /**< Must be set to true if deleteGnssDataMask is being passed */
+  qmiLocDeleteGnssDataMaskT_v02 deleteGnssDataMask;
+  /**<   Mask for the GNSS data that is to be deleted.
+
+ Valid values: \n
+      - QMI_LOC_MASK_DELETE_GPS_SVDIR (0x00000001) --  Mask to delete GPS SVDIR
+      - QMI_LOC_MASK_DELETE_GPS_SVSTEER (0x00000002) --  Mask to delete GPS SVSTEER
+      - QMI_LOC_MASK_DELETE_GPS_TIME (0x00000004) --  Mask to delete GPS time
+      - QMI_LOC_MASK_DELETE_GPS_ALM_CORR (0x00000008) --  Mask to delete almanac correlation
+      - QMI_LOC_MASK_DELETE_GLO_SVDIR (0x00000010) --  Mask to delete GLONASS SVDIR
+      - QMI_LOC_MASK_DELETE_GLO_SVSTEER (0x00000020) --  Mask to delete GLONASS SVSTEER
+      - QMI_LOC_MASK_DELETE_GLO_TIME (0x00000040) --  Mask to delete GLONASS time
+      - QMI_LOC_MASK_DELETE_GLO_ALM_CORR (0x00000080) --  Mask to delete GLONASS almanac correlation
+      - QMI_LOC_MASK_DELETE_SBAS_SVDIR (0x00000100) --  Mask to delete SBAS SVDIR
+      - QMI_LOC_MASK_DELETE_SBAS_SVSTEER (0x00000200) --  Mask to delete SBAS SVSTEER
+      - QMI_LOC_MASK_DELETE_POSITION (0x00000400) --  Mask to delete position estimate
+      - QMI_LOC_MASK_DELETE_TIME (0x00000800) --  Mask to delete time estimate
+      - QMI_LOC_MASK_DELETE_IONO (0x00001000) --  Mask to delete IONO
+      - QMI_LOC_MASK_DELETE_UTC (0x00002000) --  Mask to delete UTC estimate
+      - QMI_LOC_MASK_DELETE_HEALTH (0x00004000) --  Mask to delete SV health record
+      - QMI_LOC_MASK_DELETE_SADATA (0x00008000) --  Mask to delete SADATA
+      - QMI_LOC_MASK_DELETE_RTI (0x00010000) --  Mask to delete RTI
+      - QMI_LOC_MASK_DELETE_SV_NO_EXIST (0x00020000) --  Mask to delete SV_NO_EXIST
+      - QMI_LOC_MASK_DELETE_FREQ_BIAS_EST (0x00040000) --  Mask to delete frequency bias estimate
+      - QMI_LOC_MASK_DELETE_BDS_SVDIR (0x00080000) --  Mask to delete BDS SVDIR
+      - QMI_LOC_MASK_DELETE_BDS_SVSTEER (0x00100000) --  Mask to delete BDS SVSTEER
+      - QMI_LOC_MASK_DELETE_BDS_TIME (0x00200000) --  Mask to delete BDS time
+      - QMI_LOC_MASK_DELETE_BDS_ALM_CORR (0x00400000) --  Mask to delete BDS almanac correlation
+      - QMI_LOC_MASK_DELETE_GNSS_SV_BLACKLIST_GPS (0x00800000) --  Mask to delete GNSS SV blacklist GPS
+      - QMI_LOC_MASK_DELETE_GNSS_SV_BLACKLIST_GLO (0x01000000) --  Mask to delete GNSS SV blacklist GLO
+      - QMI_LOC_MASK_DELETE_GNSS_SV_BLACKLIST_BDS (0x02000000) --  Mask to delete GNSS SV blacklist BDS
+      - QMI_LOC_MASK_DELETE_GNSS_SV_BLACKLIST_GAL (0x04000000) --  Mask to delete GNSS SV blacklist GAL
+      - QMI_LOC_MASK_DELETE_GAL_SVDIR (0x08000000) --  Mask to delete GAL SVDIR
+      - QMI_LOC_MASK_DELETE_GAL_SVSTEER (0x10000000) --  Mask to delete GAL SVSTEER
+      - QMI_LOC_MASK_DELETE_GAL_TIME (0x20000000) --  Mask to delete GAL time
+      - QMI_LOC_MASK_DELETE_GAL_ALM_CORR (0x40000000) --  Mask to delete GAL almanac correlation
+ */
+
+  /* Optional */
+  /*  Delete Cell Database */
+  uint8_t deleteCellDbDataMask_valid;  /**< Must be set to true if deleteCellDbDataMask is being passed */
+  qmiLocDeleteCelldbDataMaskT_v02 deleteCellDbDataMask;
+  /**<   Mask for the cell database assistance data that is to be deleted.
+
+       Valid values: \begin{itemize1}
+       \item    0x00000001 -- DELETE_CELLDB_ POS
+       \item    0x00000002 -- DELETE_CELLDB_ LATEST_GPS_POS
+       \item    0x00000004 -- DELETE_CELLDB_ OTA_POS
+       \item    0x00000008 -- DELETE_CELLDB_ EXT_REF_POS
+       \item    0x00000010 -- DELETE_CELLDB_ TIMETAG
+       \item    0x00000020 -- DELETE_CELLDB_ CELLID
+       \item    0x00000040 -- DELETE_CELLDB_ CACHED_CELLID
+       \item    0x00000080 -- DELETE_CELLDB_ LAST_SRV_CELL
+       \item    0x00000100 -- DELETE_CELLDB_ CUR_SRV_CELL
+       \item    0x00000200 -- DELETE_CELLDB_ NEIGHBOR_INFO
+       \vspace{-0.18in} \end{itemize1}
+  */
+
+  /* Optional */
+  /*  Delete Clock Info */
+  uint8_t deleteClockInfoMask_valid;  /**< Must be set to true if deleteClockInfoMask is being passed */
+  qmiLocDeleteClockInfoMaskT_v02 deleteClockInfoMask;
+  /**<   Mask for the clock information assistance data that is to be deleted.
+
+ Valid bitmasks: \n
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_TIME_EST (0x00000001) --  Mask to delete time estimate from clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_FREQ_EST (0x00000002) --  Mask to delete frequency estimate from clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_WEEK_NUMBER (0x00000004) --  Mask to delete week number from clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_RTC_TIME (0x00000008) --  Mask to delete RTC time from clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_TIME_TRANSFER (0x00000010) --  Mask to delete time transfer from clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_GPSTIME_EST (0x00000020) --  Mask to delete GPS time estimate from clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_GLOTIME_EST (0x00000040) --  Mask to delete GLONASS time estimate from clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_GLODAY_NUMBER (0x00000080) --  Mask to delete GLONASS day number from clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_GLO4YEAR_NUMBER (0x00000100) --  Mask to delete GLONASS four year number from clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_GLO_RF_GRP_DELAY (0x00000200) --  Mask to delete GLONASS RF GRP delay from clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_DISABLE_TT (0x00000400) --  Mask to delete disable TT from clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_GG_LEAPSEC (0x00000800) --  Mask to delete a BDS time estimate from the clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_GG_GGTB (0x00001000) --  Mask to delete a BDS time estimate from the clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_BDSTIME_EST (0x00002000) --  Mask to delete a BDS time estimate from the clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_GB_GBTB (0x00004000) --  Mask to delete Glonass-to-BDS time bias-related information from the
+      clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_BG_BGTB (0x00008000) --  Mask to delete BDS-to-GLONASS time bias-related information from the
+       clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_BDSWEEK_NUMBER (0x00010000) --  Mask to delete the BDS week number from the clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_BDS_RF_GRP_DELAY (0x00020000) --  Mask to delete the BDS RF GRP delay from the clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_GALTIME_EST (0x00040000) --  Mask to delete a GAL time estimate from the clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_GALTOGPS_TB (0x00080000) --  Mask to delete GAL-to-GPS time bias-related information from the
+      clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_GALTOGLO_TB (0x00100000) --  Mask to delete GAL-to-GLO time bias-related information from the
+      clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_GALTOBDS_TB (0x00200000) --  Mask to delete GAL-to-BDS time bias-related information from the
+      clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_GALWEEK_NUMBER (0x00800000) --  Mask to delete the GAL week number from the clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_GAL_RF_GRP_DELAY (0x01000000) --  Mask to delete the GAL RF GRP delay from the clock information
+ */
+
+  /* Optional */
+  /*  Delete BDS SV Info */
+  uint8_t deleteBdsSvInfoList_valid;  /**< Must be set to true if deleteBdsSvInfoList is being passed */
+  uint32_t deleteBdsSvInfoList_len;  /**< Must be set to # of elements in deleteBdsSvInfoList */
+  qmiLocDeleteBDSSvInfoStructT_v02 deleteBdsSvInfoList[QMI_LOC_DELETE_MAX_BDS_SV_INFO_LENGTH_V02];
+  /**<   \vspace{0.06in} \n List of BDS satellites for which the assistance data is to be deleted.
+  */
+
+  /* Optional */
+  /*  Delete GAL SV Info */
+  uint8_t deleteGalSvInfoList_valid;  /**< Must be set to true if deleteGalSvInfoList is being passed */
+  uint32_t deleteGalSvInfoList_len;  /**< Must be set to # of elements in deleteGalSvInfoList */
+  qmiLocDeleteGALSvInfoStructT_v02 deleteGalSvInfoList[QMI_LOC_DELETE_MAX_GAL_SV_INFO_LENGTH_V02];
+  /**<   \vspace{0.06in} \n List of GAL satellites for which the assistance data is to be deleted.
+  */
+}qmiLocDeleteAssistDataReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; This command is used to delete the location engine
+                    assistance data. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Delete Assist Data Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Delete Assist Data request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+}qmiLocDeleteAssistDataIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Enables/disables XTRA-T session control. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Enable XTRA-T */
+  uint8_t xtraTSessionControl;
+  /**<   Indicates whether to enable XTRA-T:\n
+       - 0x01 (TRUE) -- Enable XTRA-T \n
+       - 0x00 (FALSE) -- Disable XTRA-T */
+}qmiLocSetXtraTSessionControlReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Enables/disables XTRA-T session control. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Set XTRA-T Session Control Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Set XTRA-T Session Control request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+}qmiLocSetXtraTSessionControlIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Gets the XTRA-T session control value from the location
+                    engine. */
+typedef struct {
+  /* This element is a placeholder to prevent the declaration of
+     an empty struct.  DO NOT USE THIS FIELD UNDER ANY CIRCUMSTANCE */
+  char __placeholder;
+}qmiLocGetXtraTSessionControlReqMsgT_v02;
+
+  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Gets the XTRA-T session control value from the location
+                    engine. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Get XTRA-T Session Control Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Get XTRA-T Session Control request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Optional */
+  /*  Enable/Disable XTRA-T */
+  uint8_t xtraTSessionControl_valid;  /**< Must be set to true if xtraTSessionControl is being passed */
+  uint8_t xtraTSessionControl;
+  /**<   Indicates whether to enable XTRA-T:\n
+       - 0x01 (TRUE) -- Enable XTRA-T \n
+       - 0x00 (FALSE) -- Disable XTRA-T */
+}qmiLocGetXtraTSessionControlIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint32_t wifiPositionTime;
+  /**<   Common counter (typically, the number of milliseconds since bootup).
+        This field is only to be provided if the modem and host processors are
+        synchronized. */
+}qmiLocWifiFixTimeStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCWIFIFIXERRORCODEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_WIFI_FIX_ERROR_SUCCESS_V02 = 0, /**<  Wi-Fi fix is successful. */
+  eQMI_LOC_WIFI_FIX_ERROR_WIFI_NOT_AVAILABLE_V02 = 1, /**<  Wi-Fi fix failed because Wi-Fi is not available on the device.  */
+  eQMI_LOC_WIFI_FIX_ERROR_NO_AP_FOUND_V02 = 2, /**<  Wi-Fi fix failed because no access points were found.  */
+  eQMI_LOC_WIFI_FIX_ERROR_UNAUTHORIZED_V02 = 3, /**<  Wi-Fi fix failed because the server denied access due to bad authorization
+   code.  */
+  eQMI_LOC_WIFI_FIX_ERROR_SERVER_UNAVAILABLE_V02 = 4, /**<  Wi-Fi fix failed because the Wi-Fi server was unavailable.  */
+  eQMI_LOC_WIFI_FIX_ERROR_LOCATION_CANNOT_BE_DETERMINED_V02 = 5, /**<  Wi-Fi fix failed even though APs were found and the server could be reached.
+   This may be because the APs found are not in the database.  */
+  eQMI_LOC_WIFI_FIX_ERROR_UNKNOWN_V02 = 6, /**<  Wi-Fi fix failed, but the cause could not be determined.  */
+  QMILOCWIFIFIXERRORCODEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocWifiFixErrorCodeEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  double lat;
+  /**<   Wi-Fi position latitude. \n
+        - Type: Floating point \n
+        - Units: Degrees */
+
+  double lon;
+  /**<   Wi-Fi position longitude. \n
+        - Type: Floating point \n
+        - Units: Degrees */
+
+  uint16_t hepe;
+  /**<   Wi-Fi position HEPE.\n
+        - Units: Meters */
+
+  uint8_t numApsUsed;
+  /**<   Number of Access Points (AP) used to generate a fix. */
+
+  qmiLocWifiFixErrorCodeEnumT_v02 fixErrorCode;
+  /**<   Wi-Fi position error code; set to 0 if the fix succeeds. This position
+ is only used by a module if the value is 0. If there was a failure,
+ the error code provided by the Wi-Fi positioning system can be provided
+ here.
+
+ Valid values: \n
+      - eQMI_LOC_WIFI_FIX_ERROR_SUCCESS (0) --  Wi-Fi fix is successful.
+      - eQMI_LOC_WIFI_FIX_ERROR_WIFI_NOT_AVAILABLE (1) --  Wi-Fi fix failed because Wi-Fi is not available on the device.
+      - eQMI_LOC_WIFI_FIX_ERROR_NO_AP_FOUND (2) --  Wi-Fi fix failed because no access points were found.
+      - eQMI_LOC_WIFI_FIX_ERROR_UNAUTHORIZED (3) --  Wi-Fi fix failed because the server denied access due to bad authorization
+   code.
+      - eQMI_LOC_WIFI_FIX_ERROR_SERVER_UNAVAILABLE (4) --  Wi-Fi fix failed because the Wi-Fi server was unavailable.
+      - eQMI_LOC_WIFI_FIX_ERROR_LOCATION_CANNOT_BE_DETERMINED (5) --  Wi-Fi fix failed even though APs were found and the server could be reached.
+   This may be because the APs found are not in the database.
+      - eQMI_LOC_WIFI_FIX_ERROR_UNKNOWN (6) --  Wi-Fi fix failed, but the cause could not be determined.
+ */
+}qmiLocWifiFixPosStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+typedef uint8_t qmiLocWifiApQualifierMaskT_v02;
+#define QMI_LOC_WIFI_AP_QUALIFIER_BEING_USED_V02 ((qmiLocWifiApQualifierMaskT_v02)0x01) /**<  Access point is being used by the WPS.  */
+#define QMI_LOC_WIFI_AP_QUALIFIER_HIDDEN_SSID_V02 ((qmiLocWifiApQualifierMaskT_v02)0x02) /**<  AP does not broadcast SSID.  */
+#define QMI_LOC_WIFI_AP_QUALIFIER_PRIVATE_V02 ((qmiLocWifiApQualifierMaskT_v02)0x04) /**<  AP has encryption turned on.  */
+#define QMI_LOC_WIFI_AP_QUALIFIER_INFRASTRUCTURE_MODE_V02 ((qmiLocWifiApQualifierMaskT_v02)0x08) /**<  AP is in infrastructure mode and not in ad-hoc/unknown mode.  */
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint8_t macAddr[QMI_LOC_WIFI_MAC_ADDR_LENGTH_V02];
+  /**<   Associated MAC address of the AP. \n
+        - Type: Array of unsigned integers \n
+        - Address length: 6
+   */
+
+  int32_t rssi;
+  /**<   Receive signal strength indicator.\n
+        - Units: dBm (offset with +100 dB) */
+
+  uint16_t channel;
+  /**<   Wi-Fi channel on which a beacon was received. */
+
+  qmiLocWifiApQualifierMaskT_v02 apQualifier;
+  /**<   A bitmask of Boolean qualifiers for APs.
+        All unused bits in this mask must be set to 0.
+
+        Valid values: \n
+          - 0x01 -- BEING_USED \n
+          - 0x02 -- HIDDEN_SSID \n
+          - 0x04 -- PRIVATE \n
+          - 0x08 -- INFRASTRUCTURE_MODE
+         */
+}qmiLocWifiApInfoStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  char ssid[QMI_LOC_MAX_WIFI_AP_SSID_STR_LENGTH_V02 + 1];
+  /**<   NULL-terminated SSID string of the Wi-Fi AP. Its maximum length according to the ASCII standard is 32 octets. */
+}qmiLocWifiApSsidStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Injects the Wi-Fi position. */
+typedef struct {
+
+  /* Optional */
+  /*  Wi-Fi Fix Time */
+  uint8_t wifiFixTime_valid;  /**< Must be set to true if wifiFixTime is being passed */
+  qmiLocWifiFixTimeStructT_v02 wifiFixTime;
+  /**<   \vspace{0.06in} \n Time of Wi-Fi position fix. */
+
+  /* Optional */
+  /*  Wi-Fi Position */
+  uint8_t wifiFixPosition_valid;  /**< Must be set to true if wifiFixPosition is being passed */
+  qmiLocWifiFixPosStructT_v02 wifiFixPosition;
+  /**<   \vspace{0.06in} \n Wi-Fi position fix. */
+
+  /* Optional */
+  /*  Wi-Fi Access Point Information */
+  uint8_t apInfo_valid;  /**< Must be set to true if apInfo is being passed */
+  uint32_t apInfo_len;  /**< Must be set to # of elements in apInfo */
+  qmiLocWifiApInfoStructT_v02 apInfo[QMI_LOC_WIFI_MAX_REPORTED_APS_PER_MSG_V02];
+  /**<   \vspace{0.06in} \n AP scan list.
+        SSID of the Wi-Fi AP.
+        The ordering of the Wi-Fi AP SSID list should matchthe Wi-Fi AP MAC address list if both are provided,
+        that is, the first element of the Wi-Fi AP SSID list must be the SSID of the AP whose MAC
+        address is in the first element in the Wi-Fi AP Info MAC Address, and so on. */
+
+  /* Optional */
+  /*  Horizontal Reliability */
+  uint8_t horizontalReliability_valid;  /**< Must be set to true if horizontalReliability is being passed */
+  qmiLocReliabilityEnumT_v02 horizontalReliability;
+  /**<   Specifies the reliability of the horizontal position.
+
+ Valid values: \n
+      - eQMI_LOC_RELIABILITY_NOT_SET (0) --  Location reliability is not set
+      - eQMI_LOC_RELIABILITY_VERY_LOW (1) --  Location reliability is very low; use it at your own risk
+      - eQMI_LOC_RELIABILITY_LOW (2) --  Location reliability is low; little or no cross-checking is possible
+      - eQMI_LOC_RELIABILITY_MEDIUM (3) --  Location reliability is medium; limited cross-check passed
+      - eQMI_LOC_RELIABILITY_HIGH (4) --  Location reliability is high; strong cross-check passed
+ */
+
+  /* Optional */
+  /*  Raw HEPE */
+  uint8_t rawHepe_valid;  /**< Must be set to true if rawHepe is being passed */
+  uint16_t rawHepe;
+  /**<   Wi-Fi position raw HEPE, which has no optimization.\n
+        - Units: Meters */
+
+  /* Optional */
+  /*  Wi-Fi AP SSID String */
+  uint8_t wifiApSsidInfo_valid;  /**< Must be set to true if wifiApSsidInfo is being passed */
+  uint32_t wifiApSsidInfo_len;  /**< Must be set to # of elements in wifiApSsidInfo */
+  qmiLocWifiApSsidStructT_v02 wifiApSsidInfo[QMI_LOC_WIFI_MAX_REPORTED_APS_PER_MSG_V02];
+  /**<   \vspace{0.04in} \n
+        The ordering of the Wi-Fi AP SSID list should match the Wi-Fi AP MAC address list if both are provided,
+        that is, the first element of the Wi-Fi AP SSID list must be the SSID of the AP whose MAC
+        address is in the first element in the Wi-Fi AP Info MAC address, and so on.*/
+}qmiLocInjectWifiPositionReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Injects the Wi-Fi position. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Inject Wi-Fi Position Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Inject Wi-Fi Position request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+}qmiLocInjectWifiPositionIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCWIFISTATUSENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_WIFI_STATUS_AVAILABLE_V02 = 1, /**<  Wi-Fi is available  */
+  eQMI_LOC_WIFI_STATUS_UNAVAILABLE_V02 = 2, /**<  Wi-Fi is not available  */
+  QMILOCWIFISTATUSENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocWifiStatusEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Notifies the location engine of the Wi-Fi status. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Availablility of Wi-Fi */
+  qmiLocWifiStatusEnumT_v02 wifiStatus;
+  /**<   Wi-Fi status information.
+
+ Valid values: \n
+      - eQMI_LOC_WIFI_STATUS_AVAILABLE (1) --  Wi-Fi is available
+      - eQMI_LOC_WIFI_STATUS_UNAVAILABLE (2) --  Wi-Fi is not available
+ */
+}qmiLocNotifyWifiStatusReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Notifies the location engine of the Wi-Fi status. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Status of Notify Wi-Fi Status Request */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Notify Wi-Fi Status request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+}qmiLocNotifyWifiStatusIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Gets the mask of the events for which a client has
+                    registered. */
+typedef struct {
+  /* This element is a placeholder to prevent the declaration of
+     an empty struct.  DO NOT USE THIS FIELD UNDER ANY CIRCUMSTANCE */
+  char __placeholder;
+}qmiLocGetRegisteredEventsReqMsgT_v02;
+
+  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Gets the mask of the events for which a client has
+                    registered. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Get Registered Events Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Get Registered Events request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Optional */
+  /*  Event Registration Mask */
+  uint8_t eventRegMask_valid;  /**< Must be set to true if eventRegMask is being passed */
+  qmiLocEventRegMaskT_v02 eventRegMask;
+  /**<   Event registration mask.
+ Valid bitmasks: \n
+      - QMI_LOC_EVENT_MASK_POSITION_REPORT (0x00000001) --  The control point must enable this mask to receive position report
+       event indications.
+      - QMI_LOC_EVENT_MASK_GNSS_SV_INFO (0x00000002) --  The control point must enable this mask to receive satellite report
+       event indications. These reports are sent at a 1 Hz rate.
+      - QMI_LOC_EVENT_MASK_NMEA (0x00000004) --  The control point must enable this mask to receive NMEA reports for
+       position and satellites in view. The report is at a 1 Hz rate.
+      - QMI_LOC_EVENT_MASK_NI_NOTIFY_VERIFY_REQ (0x00000008) --  The control point must enable this mask to receive NI Notify/Verify request
+       event indications.
+      - QMI_LOC_EVENT_MASK_INJECT_TIME_REQ (0x00000010) --  The control point must enable this mask to receive time injection request
+       event indications.
+      - QMI_LOC_EVENT_MASK_INJECT_PREDICTED_ORBITS_REQ (0x00000020) --  The control point must enable this mask to receive predicted orbits request
+       event indications.
+      - QMI_LOC_EVENT_MASK_INJECT_POSITION_REQ (0x00000040) --  The control point must enable this mask to receive position injection request
+       event indications.
+      - QMI_LOC_EVENT_MASK_ENGINE_STATE (0x00000080) --  The control point must enable this mask to receive engine state report
+       event indications.
+      - QMI_LOC_EVENT_MASK_FIX_SESSION_STATE (0x00000100) --  The control point must enable this mask to receive fix session status report
+       event indications.
+      - QMI_LOC_EVENT_MASK_WIFI_REQ (0x00000200) --  The control point must enable this mask to receive Wi-Fi position request
+       event indications.
+      - QMI_LOC_EVENT_MASK_SENSOR_STREAMING_READY_STATUS (0x00000400) --  The control point must enable this mask to receive notifications from the
+       location engine indicating its readiness to accept data from the
+       sensors (accelerometer, gyroscope, etc.).
+      - QMI_LOC_EVENT_MASK_TIME_SYNC_REQ (0x00000800) --  The control point must enable this mask to receive time sync requests
+       from the GPS engine. Time sync enables the GPS engine to synchronize
+       its clock with the sensor processor's clock.
+      - QMI_LOC_EVENT_MASK_SET_SPI_STREAMING_REPORT (0x00001000) --  The control point must enable this mask to receive Stationary Position
+       Indicator (SPI) streaming report indications.
+      - QMI_LOC_EVENT_MASK_LOCATION_SERVER_CONNECTION_REQ (0x00002000) --  The control point must enable this mask to receive location server
+       requests. These requests are generated when the service wishes to
+       establish a connection with a location server.
+      - QMI_LOC_EVENT_MASK_NI_GEOFENCE_NOTIFICATION (0x00004000) --  The control point must enable this mask to receive notifications
+       related to network-initiated Geofences. These events notify the client
+       when a network-initiated Geofence is added, deleted, or edited.
+      - QMI_LOC_EVENT_MASK_GEOFENCE_GEN_ALERT (0x00008000) --  The control point must enable this mask to receive Geofence alerts.
+       These alerts are generated to inform the client of the changes that may
+       affect a Geofence, e.g., if GPS is turned off or if the network is
+       unavailable.
+      - QMI_LOC_EVENT_MASK_GEOFENCE_BREACH_NOTIFICATION (0x00010000) --  The control point must enable this mask to receive notifications when
+       a Geofence is breached. These events are generated when a UE enters
+       or leaves the perimeter of a Geofence. This breach report is for a single
+       Geofence .
+      - QMI_LOC_EVENT_MASK_PEDOMETER_CONTROL (0x00020000) --  The control point must enable this mask to register for pedometer
+       control requests from the location engine. The location engine sends
+       this event to control the injection of pedometer reports.
+      - QMI_LOC_EVENT_MASK_MOTION_DATA_CONTROL (0x00040000) --  The control point must enable this mask to register for motion data
+       control requests from the location engine. The location engine sends
+       this event to control the injection of motion data.
+      - QMI_LOC_EVENT_MASK_BATCH_FULL_NOTIFICATION (0x00080000) --  The control point must enable this mask to receive notification when
+       a batch is full. The location engine sends this event to notify of Batch Full
+       for ongoing batching session.
+      - QMI_LOC_EVENT_MASK_LIVE_BATCHED_POSITION_REPORT (0x00100000) --  The control point must enable this mask to receive position report
+       indications along with an ongoing batching session. The location engine sends
+       this event to notify the batched position report while a batching session
+       is ongoing.
+      - QMI_LOC_EVENT_MASK_INJECT_WIFI_AP_DATA_REQ (0x00200000) --  The control point must enable this mask to receive Wi-Fi AP data inject request
+       event indications.
+      - QMI_LOC_EVENT_MASK_GEOFENCE_BATCH_BREACH_NOTIFICATION (0x00400000) --  The control point must enable this mask to receive notifications when
+       a Geofence is breached. These events are generated when a UE enters
+       or leaves the perimeter of a Geofence. This breach notification is for
+       multiple Geofences. Breaches from multiple Geofences are all batched and
+       sent in the same notification .
+      - QMI_LOC_EVENT_MASK_VEHICLE_DATA_READY_STATUS (0x00800000) --  The control point must enable this mask to receive notifications from the
+       location engine indicating its readiness to accept vehicle data (vehicle
+       accelerometer, vehicle angular rate, vehicle odometry, etc.).
+      - QMI_LOC_EVENT_MASK_GNSS_MEASUREMENT_REPORT (0x01000000) --  The control point must enable this mask to receive system clock and satellite
+       measurement report events (system clock, SV time, Doppler, etc.). Reports are
+       generated only for the GNSS satellite constellations that are enabled using
+       QMI_LOC_SET_GNSS_CONSTELL_REPORT_CONFIG.
+      - QMI_LOC_EVENT_MASK_GNSS_SV_POLYNOMIAL_REPORT (0x02000000) --  The control point must enable this mask to receive satellite position
+        reports as polynomials. Reports are generated only for the GNSS satellite
+        constellations that are enabled using QMI_LOC_SET_GNSS_CONSTELL_REPORT_CONFIG.
+      - QMI_LOC_EVENT_MASK_GEOFENCE_PROXIMITY_NOTIFICATION (0x04000000) --  The control point must enable this mask to receive notifications when a Geofence proximity is entered
+  and exited. The proximity of a Geofence may be due to different contexts. These contexts are identified
+  using the context ID in this indication. The context of a Geofence may contain Wi-Fi area ID lists, IBeacon lists,
+  Cell-ID list, and so forth.
+      - QMI_LOC_EVENT_MASK_GDT_UPLOAD_BEGIN_REQ (0x08000000) --  The control point must enable this mask to receive Generic Data Transport (GDT)
+        upload session begin request event indications.
+      - QMI_LOC_EVENT_MASK_GDT_UPLOAD_END_REQ (0x10000000) --  The control point must enable this mask to receive GDT
+        upload session end request event indications.
+      - QMI_LOC_EVENT_MASK_GEOFENCE_BATCH_DWELL_NOTIFICATION (0x20000000) --  The control point must enable this mask to receive notifications when
+       a Geofence is dwelled. These events are generated when a UE enters
+       or leaves the perimeter of a Geofence and dwells inside or outside for a specified time.
+       This dwell notification is for multiple Geofences. Dwells from multiple Geofences are all batched and
+       sent in the same notification.
+      - QMI_LOC_EVENT_MASK_GET_TIME_ZONE_REQ (0x40000000) --  The control point must enable this mask to receive requests for time zone information from
+       the service. These events are generated when there is a need for time zone information in the
+       service.
+      - QMI_LOC_EVENT_MASK_BATCHING_STATUS (0x80000000) --  The control point must enable this mask to receive asynchronous events related
+       to batching.
+ */
+}qmiLocGetRegisteredEventsIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCOPERATIONMODEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_OPER_MODE_DEFAULT_V02 = 1, /**<  Use the default engine mode  */
+  eQMI_LOC_OPER_MODE_MSB_V02 = 2, /**<  Use the MS-based mode  */
+  eQMI_LOC_OPER_MODE_MSA_V02 = 3, /**<  Use the MS-assisted mode  */
+  eQMI_LOC_OPER_MODE_STANDALONE_V02 = 4, /**<  Use Standalone mode  */
+  eQMI_LOC_OPER_MODE_CELL_ID_V02 = 5, /**<  Use cell ID; this mode is only valid for GSM/UMTS networks  */
+  eQMI_LOC_OPER_MODE_WWAN_V02 = 6, /**<  Use WWAN measurements to calculate the position; if this mode is
+       set, AFLT will be used for 1X networks and OTDOA will be used
+       for LTE networks  */
+  QMILOCOPERATIONMODEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocOperationModeEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Tells the engine to use the specified operation mode while
+                    making the position fixes. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Operation Mode */
+  qmiLocOperationModeEnumT_v02 operationMode;
+  /**<   Preferred operation mode.
+
+ Valid values: \n
+      - eQMI_LOC_OPER_MODE_DEFAULT (1) --  Use the default engine mode
+      - eQMI_LOC_OPER_MODE_MSB (2) --  Use the MS-based mode
+      - eQMI_LOC_OPER_MODE_MSA (3) --  Use the MS-assisted mode
+      - eQMI_LOC_OPER_MODE_STANDALONE (4) --  Use Standalone mode
+      - eQMI_LOC_OPER_MODE_CELL_ID (5) --  Use cell ID; this mode is only valid for GSM/UMTS networks
+      - eQMI_LOC_OPER_MODE_WWAN (6) --  Use WWAN measurements to calculate the position; if this mode is
+       set, AFLT will be used for 1X networks and OTDOA will be used
+       for LTE networks
+ */
+
+  /* Optional */
+  /*  Minimum Interval Between Position Reports */
+  uint8_t minInterval_valid;  /**< Must be set to true if minInterval is being passed */
+  uint32_t minInterval;
+  /**<   Minimum time interval, specified by the control point, that must elapse between
+       position reports. \n
+       - Units: milliseconds \n
+       - Default: 1000 ms
+  */
+}qmiLocSetOperationModeReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Tells the engine to use the specified operation mode while
+                    making the position fixes. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Set Operation Mode Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Set Operation Mode request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+}qmiLocSetOperationModeIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Gets the current operation mode from the engine. */
+typedef struct {
+  /* This element is a placeholder to prevent the declaration of
+     an empty struct.  DO NOT USE THIS FIELD UNDER ANY CIRCUMSTANCE */
+  char __placeholder;
+}qmiLocGetOperationModeReqMsgT_v02;
+
+  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Gets the current operation mode from the engine. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Get Operation Mode Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Get Operation Mode request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Optional */
+  /*  Operation Mode */
+  uint8_t operationMode_valid;  /**< Must be set to true if operationMode is being passed */
+  qmiLocOperationModeEnumT_v02 operationMode;
+  /**<   Current operation mode.
+
+ Valid values: \n
+      - eQMI_LOC_OPER_MODE_DEFAULT (1) --  Use the default engine mode
+      - eQMI_LOC_OPER_MODE_MSB (2) --  Use the MS-based mode
+      - eQMI_LOC_OPER_MODE_MSA (3) --  Use the MS-assisted mode
+      - eQMI_LOC_OPER_MODE_STANDALONE (4) --  Use Standalone mode
+      - eQMI_LOC_OPER_MODE_CELL_ID (5) --  Use cell ID; this mode is only valid for GSM/UMTS networks
+      - eQMI_LOC_OPER_MODE_WWAN (6) --  Use WWAN measurements to calculate the position; if this mode is
+       set, AFLT will be used for 1X networks and OTDOA will be used
+       for LTE networks
+ */
+}qmiLocGetOperationModeIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to set the SPI status, which
+                    indicates whether the device is stationary. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Stationary Status */
+  uint8_t stationary;
+  /**<   Indicates whether the device is stationary:
+       \begin{itemize1}
+       \item    0x00 (FALSE) -- Device is not stationary
+       \item    0x01 (TRUE)  -- Device is stationary
+       \vspace{-0.18in} \end{itemize1}*/
+
+  /* Optional */
+  /*  Confidence */
+  uint8_t confidenceStationary_valid;  /**< Must be set to true if confidenceStationary is being passed */
+  uint8_t confidenceStationary;
+  /**<   Confidence in the Stationary state expressed as a percentage.\n
+       - Range: 0 to 100 */
+}qmiLocSetSpiStatusReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to set the SPI status, which
+                    indicates whether the device is stationary. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Status of SPI Status Request */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the SPI Status request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+}qmiLocSetSpiStatusIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+typedef uint8_t qmiLocSensorDataFlagMaskT_v02;
+#define QMI_LOC_SENSOR_DATA_FLAG_SIGN_REVERSAL_V02 ((qmiLocSensorDataFlagMaskT_v02)0x01) /**<  Bitmask to specify that a sign reversal is required while interpreting
+     the sensor data; only applies to the accelerometer samples  */
+#define QMI_LOC_SENSOR_DATA_FLAG_SENSOR_TIME_IS_MODEM_TIME_V02 ((qmiLocSensorDataFlagMaskT_v02)0x02) /**<  Bitmask to specify that the sensor time stamp is the same as the modem
+       time stamp  */
+#define QMI_LOC_SENSOR_DATA_FLAG_CALIBRATED_DATA_V02 ((qmiLocSensorDataFlagMaskT_v02)0x04) /**<  Bitmask to specify that the injected sensor data is calibrated  */
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCSENSORDATATIMESOURCEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_SENSOR_TIME_SOURCE_UNSPECIFIED_V02 = 0, /**<  Sensor time source is unspecified  */
+  eQMI_LOC_SENSOR_TIME_SOURCE_COMMON_V02 = 1, /**<  Time source is common between the sensors and
+       the location engine  */
+  QMILOCSENSORDATATIMESOURCEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocSensorDataTimeSourceEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint16_t timeOffset;
+  /**<   Sample time offset. This time offset must be
+       relative to the timestamp of the first sensor data sample.\n
+       - Units: Milliseconds */
+
+  float xAxis;
+  /**<   Sensor x-axis sample. \n
+       - Units Accelerometer: Meters/seconds^2 \n
+       - Units Gyroscope:     Radians/second \n
+       - Units Magnetometer:  microTesla */
+
+  float yAxis;
+  /**<   Sensor y-axis sample. \n
+       - Units Accelerometer: Meters/seconds^2 \n
+       - Units Gyroscope:     Radians/second \n
+       - Units Magnetometer:  microTesla */
+
+  float zAxis;
+  /**<   Sensor z-axis sample. \n
+       - Units Accelerometer: Meters/seconds^2 ) \n
+       - Units Gyroscope:     Radians/second \n
+       - Units Magnetometer:  microTesla */
+}qmiLoc3AxisSensorSampleStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint32_t timeOfFirstSample;
+  /**<   Denotes a full 32-bit timestamp of the first (oldest) sample in this
+       message.The timestamp is in the time reference scale that is
+       used by the sensor time source.\n
+       - Units: Milliseconds */
+
+  qmiLocSensorDataFlagMaskT_v02 flags;
+  /**<   Flags to indicate any deviation from the default measurement
+ assumptions. All unused bits in this field must be set to 0.
+
+ Valid bitmasks:
+      - QMI_LOC_SENSOR_DATA_FLAG_SIGN_REVERSAL (0x01) --  Bitmask to specify that a sign reversal is required while interpreting
+     the sensor data; only applies to the accelerometer samples
+      - QMI_LOC_SENSOR_DATA_FLAG_SENSOR_TIME_IS_MODEM_TIME (0x02) --  Bitmask to specify that the sensor time stamp is the same as the modem
+       time stamp
+      - QMI_LOC_SENSOR_DATA_FLAG_CALIBRATED_DATA (0x04) --  Bitmask to specify that the injected sensor data is calibrated  */
+
+  uint32_t sensorData_len;  /**< Must be set to # of elements in sensorData */
+  qmiLoc3AxisSensorSampleStructT_v02 sensorData[QMI_LOC_SENSOR_DATA_MAX_SAMPLES_V02];
+  /**<   Variable length array to specify sensor samples. \n
+       - Maximum length of the array: 50 */
+}qmiLoc3AxisSensorSampleListStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint16_t timeOffset;
+  /**<   Sample time offset. This time offset must be
+       relative to the timestamp of the first sensor sample.\n
+       - Units: Milliseconds */
+
+  float temperature;
+  /**<   Sensor temperature. \n
+       - Type: Floating point \n
+       - Units: Degrees Celsius \n
+       - Range: -50 to +100.00 */
+}qmiLocSensorTemperatureSampleStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  qmiLocSensorDataTimeSourceEnumT_v02 timeSource;
+  /**<   Denotes the time source of the sensor data. Location service will use
+ this field to identify the time reference used in the
+ sensor data timestamps.
+
+ Valid values: \n
+      - eQMI_LOC_SENSOR_TIME_SOURCE_UNSPECIFIED (0) --  Sensor time source is unspecified
+      - eQMI_LOC_SENSOR_TIME_SOURCE_COMMON (1) --  Time source is common between the sensors and
+       the location engine
+ */
+
+  uint32_t timeOfFirstSample;
+  /**<   Denotes a full 32-bit timestamp of the first (oldest) sample in this
+       message. The timestamp is in the time reference scale that is
+       used by the sensor time source.\n
+       - Units: Milliseconds */
+
+  uint32_t temperatureData_len;  /**< Must be set to # of elements in temperatureData */
+  qmiLocSensorTemperatureSampleStructT_v02 temperatureData[QMI_LOC_SENSOR_DATA_MAX_SAMPLES_V02];
+  /**<   Variable length array to specify sensor temperature samples. \n
+       - Maximum length of the array: 50 */
+}qmiLocSensorTemperatureSampleListStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to inject sensor data into the
+                    GNSS location engine. */
+typedef struct {
+
+  /* Optional */
+  /*  Opaque Identifier */
+  uint8_t opaqueIdentifier_valid;  /**< Must be set to true if opaqueIdentifier is being passed */
+  uint32_t opaqueIdentifier;
+  /**<   An opaque identifier that is sent in by the client that will be echoed
+       in the indication so the client can relate the indication to the
+       request. */
+
+  /* Optional */
+  /*  3-Axis Accelerometer Data */
+  uint8_t threeAxisAccelData_valid;  /**< Must be set to true if threeAxisAccelData is being passed */
+  qmiLoc3AxisSensorSampleListStructT_v02 threeAxisAccelData;
+  /**<   \vspace{0.06in} \n Accelerometer sensor samples. */
+
+  /* Optional */
+  /*  3-Axis Gyroscope Data */
+  uint8_t threeAxisGyroData_valid;  /**< Must be set to true if threeAxisGyroData is being passed */
+  qmiLoc3AxisSensorSampleListStructT_v02 threeAxisGyroData;
+  /**<   \vspace{0.06in} \n Gyroscope sensor samples. */
+
+  /* Optional */
+  /*  3-Axis Accelerometer Data Time Source */
+  uint8_t threeAxisAccelDataTimeSource_valid;  /**< Must be set to true if threeAxisAccelDataTimeSource is being passed */
+  qmiLocSensorDataTimeSourceEnumT_v02 threeAxisAccelDataTimeSource;
+  /**<   Time source for the 3-axis accelerometer data. The location service uses
+ this field to identify the time reference used in the accelerometer data
+ timestamps. If not specified, the location service assumes that the
+ time source for the accelereometer data is unknown. \n
+ Values: \n
+      - eQMI_LOC_SENSOR_TIME_SOURCE_UNSPECIFIED (0) --  Sensor time source is unspecified
+      - eQMI_LOC_SENSOR_TIME_SOURCE_COMMON (1) --  Time source is common between the sensors and
+       the location engine
+ */
+
+  /* Optional */
+  /*  3-Axis Gyroscope Data Time Source */
+  uint8_t threeAxisGyroDataTimeSource_valid;  /**< Must be set to true if threeAxisGyroDataTimeSource is being passed */
+  qmiLocSensorDataTimeSourceEnumT_v02 threeAxisGyroDataTimeSource;
+  /**<   Time source for the 3-axis gyroscope data. The location service uses
+ this field to identify the time reference used in the gyroscope data
+ timestamps. If not specified, the location service assumes that the
+ time source for the gyroscope data is unknown. \n
+ Values: \n
+      - eQMI_LOC_SENSOR_TIME_SOURCE_UNSPECIFIED (0) --  Sensor time source is unspecified
+      - eQMI_LOC_SENSOR_TIME_SOURCE_COMMON (1) --  Time source is common between the sensors and
+       the location engine
+ */
+
+  /* Optional */
+  /*  Accelerometer Temperature Data */
+  uint8_t accelTemperatureData_valid;  /**< Must be set to true if accelTemperatureData is being passed */
+  qmiLocSensorTemperatureSampleListStructT_v02 accelTemperatureData;
+  /**<   \vspace{0.06in}  \nAccelerometer temperature samples. This data is optional and does not
+       have to be included in the message along with accelerometer data. */
+
+  /* Optional */
+  /*  Gyroscope Temperature Data */
+  uint8_t gyroTemperatureData_valid;  /**< Must be set to true if gyroTemperatureData is being passed */
+  qmiLocSensorTemperatureSampleListStructT_v02 gyroTemperatureData;
+  /**<   \vspace{0.06in} \n Gyroscope temperature samples. This data is optional and does not
+       have to be included in the message along with gyroscope data. */
+
+  /* Optional */
+  /*  3-Axis Magnetometer Data */
+  uint8_t threeAxisMagData_valid;  /**< Must be set to true if threeAxisMagData is being passed */
+  qmiLoc3AxisSensorSampleListStructT_v02 threeAxisMagData;
+  /**<   \vspace{0.06in} \n Magnetometer sensor samples. */
+
+  /* Optional */
+  /*  3-Axis Magnetometer Data Time Source */
+  uint8_t threeAxisMagDataTimeSource_valid;  /**< Must be set to true if threeAxisMagDataTimeSource is being passed */
+  qmiLocSensorDataTimeSourceEnumT_v02 threeAxisMagDataTimeSource;
+  /**<   Time source for the 3-axis magnetometer data. The location service uses
+ this field to identify the time reference used in the magnetometer data
+ timestamps. If not specified, the location service assumes that the
+ time source for the magnetometer data is unknown. \n
+ Values: \n
+      - eQMI_LOC_SENSOR_TIME_SOURCE_UNSPECIFIED (0) --  Sensor time source is unspecified
+      - eQMI_LOC_SENSOR_TIME_SOURCE_COMMON (1) --  Time source is common between the sensors and
+       the location engine
+ */
+}qmiLocInjectSensorDataReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to inject sensor data into the
+                    GNSS location engine. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Inject Sensor Data Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Inject Sensor Data request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Optional */
+  /*  Opaque Identifier */
+  uint8_t opaqueIdentifier_valid;  /**< Must be set to true if opaqueIdentifier is being passed */
+  uint32_t opaqueIdentifier;
+  /**<   Opaque identifier that was sent in by the client echoed
+       so the client can relate the indication to the request. */
+
+  /* Optional */
+  /*  Accelerometer Samples Accepted */
+  uint8_t threeAxisAccelSamplesAccepted_valid;  /**< Must be set to true if threeAxisAccelSamplesAccepted is being passed */
+  uint8_t threeAxisAccelSamplesAccepted;
+  /**<   Lets the client know how many 3-axis accelerometer samples
+       were accepted. This field is present only if the accelerometer
+       samples were sent in the request. */
+
+  /* Optional */
+  /*  Gyroscope Samples Accepted */
+  uint8_t threeAxisGyroSamplesAccepted_valid;  /**< Must be set to true if threeAxisGyroSamplesAccepted is being passed */
+  uint8_t threeAxisGyroSamplesAccepted;
+  /**<   Lets the client know how many 3-axis gyroscope samples were
+       accepted. This field is present only if the gyroscope
+       samples were sent in the request. */
+
+  /* Optional */
+  /*  Accelerometer Temperature Samples Accepted */
+  uint8_t accelTemperatureSamplesAccepted_valid;  /**< Must be set to true if accelTemperatureSamplesAccepted is being passed */
+  uint8_t accelTemperatureSamplesAccepted;
+  /**<   Lets the client know how many accelerometer temperature
+       samples were accepted. This field is present only if the accelerometer
+       temperature samples were sent in the request. */
+
+  /* Optional */
+  /*  Gyroscope Temperature Samples Accepted */
+  uint8_t gyroTemperatureSamplesAccepted_valid;  /**< Must be set to true if gyroTemperatureSamplesAccepted is being passed */
+  uint8_t gyroTemperatureSamplesAccepted;
+  /**<   Lets the client know how many gyroscope temperature samples
+       were accepted. This field is present only if the gyroscope
+       temperature samples were sent in the request. */
+
+  /* Optional */
+  /*  Magnetometer Samples Accepted */
+  uint8_t threeAxisMagSamplesAccepted_valid;  /**< Must be set to true if threeAxisMagSamplesAccepted is being passed */
+  uint8_t threeAxisMagSamplesAccepted;
+  /**<   Lets the client know how many 3-axis magnetometer samples
+       were accepted. This field is present only if the magnetometer
+       samples were sent in the request. */
+}qmiLocInjectSensorDataIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to inject time sync data. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Reference Time Sync Counter */
+  uint32_t refCounter;
+  /**<   Must be set to the value that was sent to the control point when the
+       GNSS location engine requested time sync injection. */
+
+  /* Mandatory */
+  /*  Sensor Receive Time */
+  uint32_t sensorProcRxTime;
+  /**<   Value of the sensor time when the control point received the
+       Time Sync Inject request from the GNSS location engine.
+
+       Must be monotonically increasing, jitter @latexonly $\leq$ @endlatexonly 1
+       millisecond, never stopping until the process is rebooted.\n
+       - Units: Milliseconds */
+
+  /* Mandatory */
+  /*  Sensor Transmit Time */
+  uint32_t sensorProcTxTime;
+  /**<   Value of the sensor time when the control point injects this message
+       for use by the GNSS location engine.
+
+       Must be monotonically increasing, jitter @latexonly $\leq$ @endlatexonly 1
+       millisecond, never stopping until the process is rebooted.\n
+       - Units: Milliseconds */
+}qmiLocInjectTimeSyncDataReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to inject time sync data. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Inject Time Sync Data Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Inject Time Sync Data request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+}qmiLocInjectTimeSyncDataIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCCRADLEMOUNTSTATEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_CRADLE_STATE_NOT_MOUNTED_V02 = 0, /**<  Device is mounted on the cradle */
+  eQMI_LOC_CRADLE_STATE_MOUNTED_V02 = 1, /**<  Device is not mounted on the cradle */
+  eQMI_LOC_CRADLE_STATE_UNKNOWN_V02 = 2, /**<  Unknown cradle mount state */
+  QMILOCCRADLEMOUNTSTATEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocCradleMountStateEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to get the current
+                    cradle mount configuration. */
+typedef struct {
+  /* This element is a placeholder to prevent the declaration of
+     an empty struct.  DO NOT USE THIS FIELD UNDER ANY CIRCUMSTANCE */
+  char __placeholder;
+}qmiLocGetCradleMountConfigReqMsgT_v02;
+
+  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to get the current
+                    cradle mount configuration. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Get Cradle Mount Config Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Get Cradle Mount Configuration request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Optional */
+  /*  Cradle Mount State */
+  uint8_t cradleMountState_valid;  /**< Must be set to true if cradleMountState is being passed */
+  qmiLocCradleMountStateEnumT_v02 cradleMountState;
+  /**<   Cradle Mount state set by the control point.
+
+ Valid values: \n
+      - eQMI_LOC_CRADLE_STATE_NOT_MOUNTED (0) --  Device is mounted on the cradle
+      - eQMI_LOC_CRADLE_STATE_MOUNTED (1) --  Device is not mounted on the cradle
+      - eQMI_LOC_CRADLE_STATE_UNKNOWN (2) --  Unknown cradle mount state
+ */
+
+  /* Optional */
+  /*  Cradle Mount Confidence */
+  uint8_t confidenceCradleMountState_valid;  /**< Must be set to true if confidenceCradleMountState is being passed */
+  uint8_t confidenceCradleMountState;
+  /**<   Confidence of the Cradle Mount state expressed as a percentage.\n
+       - Range: 0 to 100 */
+}qmiLocGetCradleMountConfigIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to set the current
+                    cradle mount configuration. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Cradle Mount State */
+  qmiLocCradleMountStateEnumT_v02 cradleMountState;
+  /**<   Cradle Mount state set by the control point.
+
+ Valid values: \n
+      - eQMI_LOC_CRADLE_STATE_NOT_MOUNTED (0) --  Device is mounted on the cradle
+      - eQMI_LOC_CRADLE_STATE_MOUNTED (1) --  Device is not mounted on the cradle
+      - eQMI_LOC_CRADLE_STATE_UNKNOWN (2) --  Unknown cradle mount state
+ */
+
+  /* Optional */
+  /*  Cradle Mount Confidence */
+  uint8_t confidenceCradleMountState_valid;  /**< Must be set to true if confidenceCradleMountState is being passed */
+  uint8_t confidenceCradleMountState;
+  /**<   Confidence in the Cradle Mount state expressed as a percentage.\n
+       - Range: 0 to 100 */
+}qmiLocSetCradleMountConfigReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to set the current
+                    cradle mount configuration. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Set Cradle Mount Config Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Set Cradle Mount Configuration request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+}qmiLocSetCradleMountConfigIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCEXTERNALPOWERCONFIGENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_EXTERNAL_POWER_NOT_CONNECTED_V02 = 0, /**<  Device is not connected to an external power source  */
+  eQMI_LOC_EXTERNAL_POWER_CONNECTED_V02 = 1, /**<  Device is connected to an external power source  */
+  eQMI_LOC_EXTERNAL_POWER_UNKNOWN_V02 = 2, /**<  Unknown external power state  */
+  QMILOCEXTERNALPOWERCONFIGENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocExternalPowerConfigEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to get the current
+                    external power configuration. */
+typedef struct {
+  /* This element is a placeholder to prevent the declaration of
+     an empty struct.  DO NOT USE THIS FIELD UNDER ANY CIRCUMSTANCE */
+  char __placeholder;
+}qmiLocGetExternalPowerConfigReqMsgT_v02;
+
+  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to get the current
+                    external power configuration. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Get Ext Power Config Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Get External Power Configuration request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Optional */
+  /*  External Power State */
+  uint8_t externalPowerState_valid;  /**< Must be set to true if externalPowerState is being passed */
+  qmiLocExternalPowerConfigEnumT_v02 externalPowerState;
+  /**<   Power state; injected by the control point.
+
+ Valid values: \n
+      - eQMI_LOC_EXTERNAL_POWER_NOT_CONNECTED (0) --  Device is not connected to an external power source
+      - eQMI_LOC_EXTERNAL_POWER_CONNECTED (1) --  Device is connected to an external power source
+      - eQMI_LOC_EXTERNAL_POWER_UNKNOWN (2) --  Unknown external power state
+ */
+}qmiLocGetExternalPowerConfigIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to set the current
+                    external power configuration. */
+typedef struct {
+
+  /* Mandatory */
+  /*  External Power State */
+  qmiLocExternalPowerConfigEnumT_v02 externalPowerState;
+  /**<   Power state; injected by the control point.
+
+ Valid values: \n
+      - eQMI_LOC_EXTERNAL_POWER_NOT_CONNECTED (0) --  Device is not connected to an external power source
+      - eQMI_LOC_EXTERNAL_POWER_CONNECTED (1) --  Device is connected to an external power source
+      - eQMI_LOC_EXTERNAL_POWER_UNKNOWN (2) --  Unknown external power state
+ */
+}qmiLocSetExternalPowerConfigReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to set the current
+                    external power configuration. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Set Ext Power Config Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Set External Power Configuration request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+}qmiLocSetExternalPowerConfigIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCSERVERPDNENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_APN_PROFILE_PDN_TYPE_IPV4_V02 = 0x01, /**<  IPv4 PDN type  */
+  eQMI_LOC_APN_PROFILE_PDN_TYPE_IPV6_V02 = 0x02, /**<  IPv6 PDN type  */
+  eQMI_LOC_APN_PROFILE_PDN_TYPE_IPV4V6_V02 = 0x03, /**<  IPv4v6 PDN type  */
+  eQMI_LOC_APN_PROFILE_PDN_TYPE_PPP_V02 = 0x04, /**<  PPP PDN type  */
+  QMILOCSERVERPDNENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocServerPDNEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  qmiLocServerPDNEnumT_v02 pdnType;
+  /**<   PDN type of the APN profile.
+
+ Valid values: \n
+      - eQMI_LOC_APN_PROFILE_PDN_TYPE_IPV4 (0x01) --  IPv4 PDN type
+      - eQMI_LOC_APN_PROFILE_PDN_TYPE_IPV6 (0x02) --  IPv6 PDN type
+      - eQMI_LOC_APN_PROFILE_PDN_TYPE_IPV4V6 (0x03) --  IPv4v6 PDN type
+      - eQMI_LOC_APN_PROFILE_PDN_TYPE_PPP (0x04) --  PPP PDN type
+ */
+
+  char apnName[QMI_LOC_MAX_APN_NAME_LENGTH_V02 + 1];
+  /**<   APN name.
+       \begin{itemize1}
+       \item    Type: NULL-terminated string
+       \item    Maximum string length (including NULL terminator): 101
+       \vspace{-0.18in} \end{itemize1}
+  */
+}qmiLocApnProfilesStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCSERVERREQSTATUSENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_SERVER_REQ_STATUS_SUCCESS_V02 = 1, /**<  Location server request was successful  */
+  eQMI_LOC_SERVER_REQ_STATUS_FAILURE_V02 = 2, /**<  Location server request failed  */
+  QMILOCSERVERREQSTATUSENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocServerReqStatusEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to inform the service about the
+                    status of the location server connection request that the
+                    service may have sent via the
+                    QMI_LOC_EVENT_LOCATION_SERVER_CONNECTION_REQ_IND event. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Connection Handle */
+  uint32_t connHandle;
+  /**<   Connection handle that the service specified in the
+       Location Server Connection request event. */
+
+  /* Mandatory */
+  /*  Request Type */
+  qmiLocServerRequestEnumT_v02 requestType;
+  /**<   Type of connection request service that was specified in the
+ Location Server Connection Request event.
+
+ Valid values: \n
+      - eQMI_LOC_SERVER_REQUEST_OPEN (1) --  Open a connection to the location server
+      - eQMI_LOC_SERVER_REQUEST_CLOSE (2) --  Close a connection to the location server
+ */
+
+  /* Mandatory */
+  /*  Connection Status */
+  qmiLocServerReqStatusEnumT_v02 statusType;
+  /**<   Status of the Connection request.
+
+ Valid values: \n
+      - eQMI_LOC_SERVER_REQ_STATUS_SUCCESS (1) --  Location server request was successful
+      - eQMI_LOC_SERVER_REQ_STATUS_FAILURE (2) --  Location server request failed
+ */
+
+  /* Optional */
+  /*  APN Profile */
+  uint8_t apnProfile_valid;  /**< Must be set to true if apnProfile is being passed */
+  qmiLocApnProfilesStructT_v02 apnProfile;
+  /**<   \vspace{0.06in} \n Access Point Name (APN) profile information is present only when
+       requestType is OPEN and statusType is SUCCESS. */
+}qmiLocInformLocationServerConnStatusReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to inform the service about the
+                    status of the location server connection request that the
+                    service may have sent via the
+                    QMI_LOC_EVENT_LOCATION_SERVER_CONNECTION_REQ_IND event. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Status of Inform Loc Server Conn Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Inform Location Server Connection Status request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+}qmiLocInformLocationServerConnStatusIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCVXVERSIONENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_VX_VERSION_V1_ONLY_V02 = 1, /**<  V1 VX version  */
+  eQMI_LOC_VX_VERSION_V2_ONLY_V02 = 2, /**<  V2 VX version  */
+  QMILOCVXVERSIONENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocVxVersionEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCSUPLVERSIONENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_SUPL_VERSION_1_0_V02 = 1, /**<  SUPL version 1.0  */
+  eQMI_LOC_SUPL_VERSION_2_0_V02 = 2, /**<  SUPL version 2.0  */
+  eQMI_LOC_SUPL_VERSION_2_0_2_V02 = 3, /**<    SUPL version 2.0.2  */
+  QMILOCSUPLVERSIONENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocSuplVersionEnumT_v02;
+/**
+    @}
+  */
+
+typedef uint32_t qmiLocLppConfigMaskT_v02;
+#define QMI_LOC_LPP_CONFIG_ENABLE_USER_PLANE_V02 ((qmiLocLppConfigMaskT_v02)0x00000001) /**<  Enable user plane configuration for LTE Positioning Profile (LPP)  */
+#define QMI_LOC_LPP_CONFIG_ENABLE_CONTROL_PLANE_V02 ((qmiLocLppConfigMaskT_v02)0x00000002) /**<  Enable control plane configuration for LPP  */
+typedef uint32_t qmiLocAssistedGlonassProtocolMaskT_v02;
+#define QMI_LOC_ASSISTED_GLONASS_PROTOCOL_MASK_RRC_CP_V02 ((qmiLocAssistedGlonassProtocolMaskT_v02)0x00000001) /**<  Assisted GLONASS is supported over RRC in the control plane  */
+#define QMI_LOC_ASSISTED_GLONASS_PROTOCOL_MASK_RRLP_UP_V02 ((qmiLocAssistedGlonassProtocolMaskT_v02)0x00000002) /**<  Assisted GLONASS is supported over RRLP in the user plane  */
+#define QMI_LOC_ASSISTED_GLONASS_PROTOCOL_MASK_LPP_UP_V02 ((qmiLocAssistedGlonassProtocolMaskT_v02)0x00000004) /**<  Assisted GLONASS is supported over LPP in the user plane;
+       QMI_LOC_LPP_CONFIG_ENABLE_USER_PLANE must be set
+       in the LPP configuration for this to take effect  */
+#define QMI_LOC_ASSISTED_GLONASS_PROTOCOL_MASK_LPP_CP_V02 ((qmiLocAssistedGlonassProtocolMaskT_v02)0x00000008) /**<  Assisted GLONASS is supported over LPP in the control plane;
+       QMI_LOC_LPP_CONFIG_ENABLE_CONTROL_PLANE must be set
+       in the LPP configuration for this to take effect  */
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCSUPLHASHALGOENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_SUPL_HASH_ALGO_SHA1_V02 = 0, /**<  SHA-1 hash algorithm for SUPL version 2.0 or later  */
+  eQMI_LOC_SUPL_HASH_ALGO_SHA256_V02 = 1, /**<  SHA-256 hash algorithm for SUPL version 2.0 or later  */
+  QMILOCSUPLHASHALGOENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocSuplHashAlgoEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCSUPLTLSVERSIONENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_SUPL_TLS_VERSION_1_0_V02 = 0, /**<  SUPL TLS version 1.0  */
+  eQMI_LOC_SUPL_TLS_VERSION_1_1_V02 = 1, /**<  SUPL TLS version 1.1  */
+  QMILOCSUPLTLSVERSIONENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocSuplTlsVersionEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCEMERGENCYPROTOCOLENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_EMERGENCY_PROTOCOL_WCDMA_CP_V02 = 0, /**<  Use Control Plane Protocol during an emergency while on WCDMA  */
+  eQMI_LOC_EMERGENCY_PROTOCOL_WCDMA_UP_V02 = 1, /**<  Use SUPL 2.0 emergency services during an emergency while on WCDMA  */
+  QMILOCEMERGENCYPROTOCOLENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocEmergencyProtocolEnumT_v02;
+/**
+    @}
+  */
+
+typedef uint64_t qmiLocLppeUpAuxTechMaskT_v02;
+#define QMI_LOC_LPPE_MASK_UP_DBH_V02 ((qmiLocLppeUpAuxTechMaskT_v02)0x00000001ull) /**<  Enable Device Based Hybrid (3D High Accuracy Position) mode on LPPe User Plane  */
+#define QMI_LOC_LPPE_MASK_UP_AP_WIFI_MEASUREMENT_V02 ((qmiLocLppeUpAuxTechMaskT_v02)0x00000002ull) /**<  Enable WLAN AP Measurements mode on LPPe User Plane */
+typedef uint64_t qmiLocLppeCpAuxTechMaskT_v02;
+#define QMI_LOC_LPPE_MASK_CP_DBH_V02 ((qmiLocLppeCpAuxTechMaskT_v02)0x00000001ull) /**<  Enable Device Based Hybrid (3D High Accuracy Position) mode on LPPe Control Plane  */
+#define QMI_LOC_LPPE_MASK_CP_AP_WIFI_MEASUREMENT_V02 ((qmiLocLppeCpAuxTechMaskT_v02)0x00000002ull) /**<  Enable WLAN AP Measurements mode on LPPe Control Plane */
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to configure parameters stored
+                    in the nonvolatile memory. */
+typedef struct {
+
+  /* Optional */
+  /*  SUPL Security */
+  uint8_t suplSecurity_valid;  /**< Must be set to true if suplSecurity is being passed */
+  uint8_t suplSecurity;
+  /**<   Indicates whether SUPL security is enabled.
+       \begin{itemize1}
+       \item    0x01 (TRUE) -- SUPL security is enabled
+       \item    0x00 (FALSE) -- SUPL security is disabled
+       \vspace{-0.18in} \end{itemize1} */
+
+  /* Optional */
+  /*  VX Version */
+  uint8_t vxVersion_valid;  /**< Must be set to true if vxVersion is being passed */
+  qmiLocVxVersionEnumT_v02 vxVersion;
+  /**<   VX version.
+
+ Valid values: \n
+      - eQMI_LOC_VX_VERSION_V1_ONLY (1) --  V1 VX version
+      - eQMI_LOC_VX_VERSION_V2_ONLY (2) --  V2 VX version
+ */
+
+  /* Optional */
+  /*  SUPL Version */
+  uint8_t suplVersion_valid;  /**< Must be set to true if suplVersion is being passed */
+  qmiLocSuplVersionEnumT_v02 suplVersion;
+  /**<   SUPL version.
+
+ Valid values: \n
+      - eQMI_LOC_SUPL_VERSION_1_0 (1) --  SUPL version 1.0
+      - eQMI_LOC_SUPL_VERSION_2_0 (2) --  SUPL version 2.0
+      - eQMI_LOC_SUPL_VERSION_2_0_2 (3) --    SUPL version 2.0.2
+ */
+
+  /* Optional */
+  /*  LPP Configuration */
+  uint8_t lppConfig_valid;  /**< Must be set to true if lppConfig is being passed */
+  qmiLocLppConfigMaskT_v02 lppConfig;
+  /**<   LTE Positioning Profile (LPP) configuration.
+
+      Valid bitmasks: \begin{itemize1}
+      \item    0x00000001 -- LPP_CONFIG_ ENABLE_USER_PLANE
+      \item    0x00000002 -- LPP_CONFIG_ ENABLE_CONTROL_PLANE
+      \vspace{-0.18in} \end{itemize1}
+  */
+
+  /* Optional */
+  /*  Assisted GLONASS Protocol Mask */
+  uint8_t assistedGlonassProtocolMask_valid;  /**< Must be set to true if assistedGlonassProtocolMask is being passed */
+  qmiLocAssistedGlonassProtocolMaskT_v02 assistedGlonassProtocolMask;
+  /**<   Configures the protocols that the location service supports
+ for assisted GLONASS.
+
+ Valid bitmasks: \n
+      - QMI_LOC_ASSISTED_GLONASS_PROTOCOL_MASK_RRC_CP (0x00000001) --  Assisted GLONASS is supported over RRC in the control plane
+      - QMI_LOC_ASSISTED_GLONASS_PROTOCOL_MASK_RRLP_UP (0x00000002) --  Assisted GLONASS is supported over RRLP in the user plane
+      - QMI_LOC_ASSISTED_GLONASS_PROTOCOL_MASK_LPP_UP (0x00000004) --  Assisted GLONASS is supported over LPP in the user plane;
+       QMI_LOC_LPP_CONFIG_ENABLE_USER_PLANE must be set
+       in the LPP configuration for this to take effect
+      - QMI_LOC_ASSISTED_GLONASS_PROTOCOL_MASK_LPP_CP (0x00000008) --  Assisted GLONASS is supported over LPP in the control plane;
+       QMI_LOC_LPP_CONFIG_ENABLE_CONTROL_PLANE must be set
+       in the LPP configuration for this to take effect
+ */
+
+  /* Optional */
+  /*  SUPL Hash Algorithm */
+  uint8_t suplHashAlgo_valid;  /**< Must be set to true if suplHashAlgo is being passed */
+  qmiLocSuplHashAlgoEnumT_v02 suplHashAlgo;
+  /**<   SUPL hash algorithm to be used.
+
+ Valid values: \n
+      - eQMI_LOC_SUPL_HASH_ALGO_SHA1 (0) --  SHA-1 hash algorithm for SUPL version 2.0 or later
+      - eQMI_LOC_SUPL_HASH_ALGO_SHA256 (1) --  SHA-256 hash algorithm for SUPL version 2.0 or later
+ */
+
+  /* Optional */
+  /*  SUPL TLS Version */
+  uint8_t suplTlsVersion_valid;  /**< Must be set to true if suplTlsVersion is being passed */
+  qmiLocSuplTlsVersionEnumT_v02 suplTlsVersion;
+  /**<   SUPL Transport Layer Security (TLS) version. This configuration is only
+ applicable to SUPL 2.0 or later, as SUPL 1.0 always uses TLS version 1.0.
+
+ Valid values: \n
+      - eQMI_LOC_SUPL_TLS_VERSION_1_0 (0) --  SUPL TLS version 1.0
+      - eQMI_LOC_SUPL_TLS_VERSION_1_1 (1) --  SUPL TLS version 1.1
+ */
+
+  /* Optional */
+  /*  Emergency Protocol */
+  uint8_t emergencyProtocol_valid;  /**< Must be set to true if emergencyProtocol is being passed */
+  qmiLocEmergencyProtocolEnumT_v02 emergencyProtocol;
+  /**<   Configures the protocol to be used during an emergency. \n
+ \textbf{Note:} Currently, this can only be selected on WCDMA. For GSM
+ and 1X, the UE only allows a control plane NI trigger for positioning.
+ For LTE, the UE allows either a SUPL or a control plane NI trigger.
+
+ Valid values: \n
+      - eQMI_LOC_EMERGENCY_PROTOCOL_WCDMA_CP (0) --  Use Control Plane Protocol during an emergency while on WCDMA
+      - eQMI_LOC_EMERGENCY_PROTOCOL_WCDMA_UP (1) --  Use SUPL 2.0 emergency services during an emergency while on WCDMA
+ */
+
+  /* Optional */
+  /*  Wi-Fi Scan Injection Timeout Period */
+  uint8_t wifiScanInjectTimeout_valid;  /**< Must be set to true if wifiScanInjectTimeout is being passed */
+  uint8_t wifiScanInjectTimeout;
+  /**<   Configures the timeout duration that the service waits for scan results
+  injection from the control point after the event notification is sent. \n
+       \textbf{Note:} The timeout value is in seconds. \n
+         Values: \n
+       0 to 10 seconds \n
+       The minimum value (0 seconds) is the default. At this value, the service
+       disables sending the Wi-Fi scan injection notification and ignores any
+       scan results injection request.
+  */
+
+  /* Optional */
+  /*  LPPe User Plane Configure */
+  uint8_t lppeUpConfig_valid;  /**< Must be set to true if lppeUpConfig is being passed */
+  qmiLocLppeUpAuxTechMaskT_v02 lppeUpConfig;
+  /**<   LPPe User Plane Auxiliary Technology Mask.
+
+ Valid bitmasks: \n
+      - QMI_LOC_LPPE_MASK_UP_DBH (0x00000001) --  Enable Device Based Hybrid (3D High Accuracy Position) mode on LPPe User Plane
+      - QMI_LOC_LPPE_MASK_UP_AP_WIFI_MEASUREMENT (0x00000002) --  Enable WLAN AP Measurements mode on LPPe User Plane
+ */
+
+  /* Optional */
+  /*  LPPe Control Plane Configure */
+  uint8_t lppeCpConfig_valid;  /**< Must be set to true if lppeCpConfig is being passed */
+  qmiLocLppeCpAuxTechMaskT_v02 lppeCpConfig;
+  /**<   LPPe Control Plane Auxiliary Technology Mask.
+
+ Valid bitmasks: \n
+      - QMI_LOC_LPPE_MASK_CP_DBH (0x00000001) --  Enable Device Based Hybrid (3D High Accuracy Position) mode on LPPe Control Plane
+      - QMI_LOC_LPPE_MASK_CP_AP_WIFI_MEASUREMENT (0x00000002) --  Enable WLAN AP Measurements mode on LPPe Control Plane
+ */
+}qmiLocSetProtocolConfigParametersReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+typedef uint64_t qmiLocProtocolConfigParamMaskT_v02;
+#define QMI_LOC_PROTOCOL_CONFIG_PARAM_MASK_SUPL_SECURITY_V02 ((qmiLocProtocolConfigParamMaskT_v02)0x0000000000000001ull) /**<  Mask for the SUPL security configuration parameter  */
+#define QMI_LOC_PROTOCOL_CONFIG_PARAM_MASK_VX_VERSION_V02 ((qmiLocProtocolConfigParamMaskT_v02)0x0000000000000002ull) /**<  Mask for the VX version configuration parameter  */
+#define QMI_LOC_PROTOCOL_CONFIG_PARAM_MASK_SUPL_VERSION_V02 ((qmiLocProtocolConfigParamMaskT_v02)0x0000000000000004ull) /**<  Mask for the SUPL version configuration parameter  */
+#define QMI_LOC_PROTOCOL_CONFIG_PARAM_MASK_LPP_CONFIG_V02 ((qmiLocProtocolConfigParamMaskT_v02)0x0000000000000008ull) /**<  Mask for the LPP configuration parameter  */
+#define QMI_LOC_PROTOCOL_CONFIG_PARAM_MASK_ASSISTED_GLONASS_PROTOCOL_V02 ((qmiLocProtocolConfigParamMaskT_v02)0x0000000000000010ull) /**<  Mask for the assisted GLONASS configuration parameter  */
+#define QMI_LOC_PROTOCOL_CONFIG_PARAM_MASK_SUPL_HASH_ALGO_V02 ((qmiLocProtocolConfigParamMaskT_v02)0x0000000000000020ull) /**<  Mask for the SUPL hash algorithm configuration parameter  */
+#define QMI_LOC_PROTOCOL_CONFIG_PARAM_MASK_SUPL_TLS_VERSION_V02 ((qmiLocProtocolConfigParamMaskT_v02)0x0000000000000040ull) /**<  Mask for the SUPL TLS version configuration parameter  */
+#define QMI_LOC_PROTOCOL_CONFIG_PARAM_MASK_EMERGENCY_PROTOCOL_V02 ((qmiLocProtocolConfigParamMaskT_v02)0x0000000000000080ull) /**<  Mask for the emergency protocol configuration parameter  */
+#define QMI_LOC_PROTOCOL_CONFIG_PARAM_MASK_WIFI_SCAN_INJECT_TIMEOUT_V02 ((qmiLocProtocolConfigParamMaskT_v02)0x0000000000000100ull) /**<  Mask for the Wi-Fi scan injection timeout configuration parameter  */
+#define QMI_LOC_PROTOCOL_CONFIG_PARAM_MASK_LPPE_UP_V02 ((qmiLocProtocolConfigParamMaskT_v02)0x0000000000000200ull) /**<  Mask for the LPPe user plane configuration parameter  */
+#define QMI_LOC_PROTOCOL_CONFIG_PARAM_MASK_LPPE_CP_V02 ((qmiLocProtocolConfigParamMaskT_v02)0x0000000000000400ull) /**<  Mask for the LPPe control plane configuration parameter  */
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to configure parameters stored
+                    in the nonvolatile memory. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Set Config Params Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Set Configuration Parameters request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Optional */
+  /*  Failed Parameters */
+  uint8_t failedProtocolConfigParamMask_valid;  /**< Must be set to true if failedProtocolConfigParamMask is being passed */
+  qmiLocProtocolConfigParamMaskT_v02 failedProtocolConfigParamMask;
+  /**<   Identifies parameters that were not set successfully. This field
+ is sent only if the status is not SUCCESS.
+
+ Valid bitmasks: \n
+      - QMI_LOC_PROTOCOL_CONFIG_PARAM_MASK_SUPL_SECURITY (0x0000000000000001) --  Mask for the SUPL security configuration parameter
+      - QMI_LOC_PROTOCOL_CONFIG_PARAM_MASK_VX_VERSION (0x0000000000000002) --  Mask for the VX version configuration parameter
+      - QMI_LOC_PROTOCOL_CONFIG_PARAM_MASK_SUPL_VERSION (0x0000000000000004) --  Mask for the SUPL version configuration parameter
+      - QMI_LOC_PROTOCOL_CONFIG_PARAM_MASK_LPP_CONFIG (0x0000000000000008) --  Mask for the LPP configuration parameter
+      - QMI_LOC_PROTOCOL_CONFIG_PARAM_MASK_ASSISTED_GLONASS_PROTOCOL (0x0000000000000010) --  Mask for the assisted GLONASS configuration parameter
+      - QMI_LOC_PROTOCOL_CONFIG_PARAM_MASK_SUPL_HASH_ALGO (0x0000000000000020) --  Mask for the SUPL hash algorithm configuration parameter
+      - QMI_LOC_PROTOCOL_CONFIG_PARAM_MASK_SUPL_TLS_VERSION (0x0000000000000040) --  Mask for the SUPL TLS version configuration parameter
+      - QMI_LOC_PROTOCOL_CONFIG_PARAM_MASK_EMERGENCY_PROTOCOL (0x0000000000000080) --  Mask for the emergency protocol configuration parameter
+      - QMI_LOC_PROTOCOL_CONFIG_PARAM_MASK_WIFI_SCAN_INJECT_TIMEOUT (0x0000000000000100) --  Mask for the Wi-Fi scan injection timeout configuration parameter
+      - QMI_LOC_PROTOCOL_CONFIG_PARAM_MASK_LPPE_UP (0x0000000000000200) --  Mask for the LPPe user plane configuration parameter
+      - QMI_LOC_PROTOCOL_CONFIG_PARAM_MASK_LPPE_CP (0x0000000000000400) --  Mask for the LPPe control plane configuration parameter
+ */
+}qmiLocSetProtocolConfigParametersIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to get the configuration
+                    parameters stored in the nonvolatile memory. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Config Parameters */
+  qmiLocProtocolConfigParamMaskT_v02 getProtocolConfigParamMask;
+  /**<   Mask denoting the configuration parameters to be retrieved.
+
+ Valid bitmasks: \n
+      - QMI_LOC_PROTOCOL_CONFIG_PARAM_MASK_SUPL_SECURITY (0x0000000000000001) --  Mask for the SUPL security configuration parameter
+      - QMI_LOC_PROTOCOL_CONFIG_PARAM_MASK_VX_VERSION (0x0000000000000002) --  Mask for the VX version configuration parameter
+      - QMI_LOC_PROTOCOL_CONFIG_PARAM_MASK_SUPL_VERSION (0x0000000000000004) --  Mask for the SUPL version configuration parameter
+      - QMI_LOC_PROTOCOL_CONFIG_PARAM_MASK_LPP_CONFIG (0x0000000000000008) --  Mask for the LPP configuration parameter
+      - QMI_LOC_PROTOCOL_CONFIG_PARAM_MASK_ASSISTED_GLONASS_PROTOCOL (0x0000000000000010) --  Mask for the assisted GLONASS configuration parameter
+      - QMI_LOC_PROTOCOL_CONFIG_PARAM_MASK_SUPL_HASH_ALGO (0x0000000000000020) --  Mask for the SUPL hash algorithm configuration parameter
+      - QMI_LOC_PROTOCOL_CONFIG_PARAM_MASK_SUPL_TLS_VERSION (0x0000000000000040) --  Mask for the SUPL TLS version configuration parameter
+      - QMI_LOC_PROTOCOL_CONFIG_PARAM_MASK_EMERGENCY_PROTOCOL (0x0000000000000080) --  Mask for the emergency protocol configuration parameter
+      - QMI_LOC_PROTOCOL_CONFIG_PARAM_MASK_WIFI_SCAN_INJECT_TIMEOUT (0x0000000000000100) --  Mask for the Wi-Fi scan injection timeout configuration parameter
+      - QMI_LOC_PROTOCOL_CONFIG_PARAM_MASK_LPPE_UP (0x0000000000000200) --  Mask for the LPPe user plane configuration parameter
+      - QMI_LOC_PROTOCOL_CONFIG_PARAM_MASK_LPPE_CP (0x0000000000000400) --  Mask for the LPPe control plane configuration parameter
+ */
+}qmiLocGetProtocolConfigParametersReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to get the configuration
+                    parameters stored in the nonvolatile memory. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Get Config Params Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Get Configuration Parameters request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Optional */
+  /*  SUPL Security */
+  uint8_t suplSecurity_valid;  /**< Must be set to true if suplSecurity is being passed */
+  uint8_t suplSecurity;
+  /**<   Indicates whether SUPL security is enabled.
+       \begin{itemize1}
+       \item    0x01 (TRUE) -- SUPL security is enabled
+       \item    0x00 (FALSE) -- SUPL security is disabled
+       \vspace{-0.18in} \end{itemize1}*/
+
+  /* Optional */
+  /*  VX Version */
+  uint8_t vxVersion_valid;  /**< Must be set to true if vxVersion is being passed */
+  qmiLocVxVersionEnumT_v02 vxVersion;
+  /**<   VX version.
+
+ Valid values: \n
+      - eQMI_LOC_VX_VERSION_V1_ONLY (1) --  V1 VX version
+      - eQMI_LOC_VX_VERSION_V2_ONLY (2) --  V2 VX version
+ */
+
+  /* Optional */
+  /*  SUPL Version */
+  uint8_t suplVersion_valid;  /**< Must be set to true if suplVersion is being passed */
+  qmiLocSuplVersionEnumT_v02 suplVersion;
+  /**<   SUPL version.
+
+ Valid values: \n
+      - eQMI_LOC_SUPL_VERSION_1_0 (1) --  SUPL version 1.0
+      - eQMI_LOC_SUPL_VERSION_2_0 (2) --  SUPL version 2.0
+      - eQMI_LOC_SUPL_VERSION_2_0_2 (3) --    SUPL version 2.0.2
+ */
+
+  /* Optional */
+  /*  LPP Configuration */
+  uint8_t lppConfig_valid;  /**< Must be set to true if lppConfig is being passed */
+  qmiLocLppConfigMaskT_v02 lppConfig;
+  /**<   LTE Positioning Profile (LPP) configuration.
+
+      Valid bitmasks: \begin{itemize1}
+      \item    0x00000001 -- LPP_CONFIG_ ENABLE_USER_PLANE
+      \item    0x00000002 -- LPP_CONFIG_ ENABLE_CONTROL_PLANE
+      \vspace{-0.18in} \end{itemize1}
+  */
+
+  /* Optional */
+  /*  Assisted GLONASS Protocol Mask */
+  uint8_t assistedGlonassProtocolMask_valid;  /**< Must be set to true if assistedGlonassProtocolMask is being passed */
+  qmiLocAssistedGlonassProtocolMaskT_v02 assistedGlonassProtocolMask;
+  /**<   Assisted GLONASS Protocol mask.
+
+ Valid bitmasks: \n
+      - QMI_LOC_ASSISTED_GLONASS_PROTOCOL_MASK_RRC_CP (0x00000001) --  Assisted GLONASS is supported over RRC in the control plane
+      - QMI_LOC_ASSISTED_GLONASS_PROTOCOL_MASK_RRLP_UP (0x00000002) --  Assisted GLONASS is supported over RRLP in the user plane
+      - QMI_LOC_ASSISTED_GLONASS_PROTOCOL_MASK_LPP_UP (0x00000004) --  Assisted GLONASS is supported over LPP in the user plane;
+       QMI_LOC_LPP_CONFIG_ENABLE_USER_PLANE must be set
+       in the LPP configuration for this to take effect
+      - QMI_LOC_ASSISTED_GLONASS_PROTOCOL_MASK_LPP_CP (0x00000008) --  Assisted GLONASS is supported over LPP in the control plane;
+       QMI_LOC_LPP_CONFIG_ENABLE_CONTROL_PLANE must be set
+       in the LPP configuration for this to take effect
+ */
+
+  /* Optional */
+  /*  SUPL Hash Algorithm */
+  uint8_t suplHashAlgo_valid;  /**< Must be set to true if suplHashAlgo is being passed */
+  qmiLocSuplHashAlgoEnumT_v02 suplHashAlgo;
+  /**<   SUPL hash algorithm to be used.
+
+ Valid values: \n
+      - eQMI_LOC_SUPL_HASH_ALGO_SHA1 (0) --  SHA-1 hash algorithm for SUPL version 2.0 or later
+      - eQMI_LOC_SUPL_HASH_ALGO_SHA256 (1) --  SHA-256 hash algorithm for SUPL version 2.0 or later
+ */
+
+  /* Optional */
+  /*  SUPL TLS Version */
+  uint8_t suplTlsVersion_valid;  /**< Must be set to true if suplTlsVersion is being passed */
+  qmiLocSuplTlsVersionEnumT_v02 suplTlsVersion;
+  /**<   SUPL TLS version. This configuration is only
+ applicable to SUPL 2.0 or later, as SUPL 1.0 always uses TLS version 1.0.
+
+ Valid values: \n
+      - eQMI_LOC_SUPL_TLS_VERSION_1_0 (0) --  SUPL TLS version 1.0
+      - eQMI_LOC_SUPL_TLS_VERSION_1_1 (1) --  SUPL TLS version 1.1
+ */
+
+  /* Optional */
+  /*  Emergency Protocol */
+  uint8_t emergencyProtocol_valid;  /**< Must be set to true if emergencyProtocol is being passed */
+  qmiLocEmergencyProtocolEnumT_v02 emergencyProtocol;
+  /**<   Protocol to be used during emergency.
+
+ Valid values: \n
+      - eQMI_LOC_EMERGENCY_PROTOCOL_WCDMA_CP (0) --  Use Control Plane Protocol during an emergency while on WCDMA
+      - eQMI_LOC_EMERGENCY_PROTOCOL_WCDMA_UP (1) --  Use SUPL 2.0 emergency services during an emergency while on WCDMA
+ */
+
+  /* Optional */
+  /*  Wi-Fi Scan Injection Timeout Period */
+  uint8_t wifiScanInjectTimeout_valid;  /**< Must be set to true if wifiScanInjectTimeout is being passed */
+  uint8_t wifiScanInjectTimeout;
+  /**<   Timeout duration that the service waits for a scan results
+  injection from the control point after the event notification is sent. \n
+       Values: \n
+       0 to 10 seconds
+  */
+
+  /* Optional */
+  /*  LPPe User Plane Configure */
+  uint8_t lppeUpConfig_valid;  /**< Must be set to true if lppeUpConfig is being passed */
+  qmiLocLppeUpAuxTechMaskT_v02 lppeUpConfig;
+  /**<   LPPe User Plane Auxiliary Technology Mask.
+
+ Valid bitmasks: \n
+      - QMI_LOC_LPPE_MASK_UP_DBH (0x00000001) --  Enable Device Based Hybrid (3D High Accuracy Position) mode on LPPe User Plane
+      - QMI_LOC_LPPE_MASK_UP_AP_WIFI_MEASUREMENT (0x00000002) --  Enable WLAN AP Measurements mode on LPPe User Plane
+ */
+
+  /* Optional */
+  /*  LPPe Control Plane Configure */
+  uint8_t lppeCpConfig_valid;  /**< Must be set to true if lppeCpConfig is being passed */
+  qmiLocLppeCpAuxTechMaskT_v02 lppeCpConfig;
+  /**<   LPPe Control Plane Auxiliary Technology Mask.
+
+ Valid bitmasks: \n
+      - QMI_LOC_LPPE_MASK_CP_DBH (0x00000001) --  Enable Device Based Hybrid (3D High Accuracy Position) mode on LPPe Control Plane
+      - QMI_LOC_LPPE_MASK_CP_AP_WIFI_MEASUREMENT (0x00000002) --  Enable WLAN AP Measurements mode on LPPe Control Plane
+ */
+}qmiLocGetProtocolConfigParametersIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCSENSORSCONTROLCONFIGSENSORUSEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_SENSOR_CONFIG_SENSOR_USE_ENABLE_V02 = 0, /**<  Sensors data should be requested whenever a position request is
+       received. If sensor data are injected, the positioning engine
+       attempts to improve the heading and positioning performance using sensors.
+       This is the default.
+  */
+  eQMI_LOC_SENSOR_CONFIG_SENSOR_USE_DISABLE_V02 = 1, /**<  Inertial sensors are not to be used to aid heading and position
+       improvement.  */
+  QMILOCSENSORSCONTROLCONFIGSENSORUSEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocSensorsControlConfigSensorUseEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCSENSORSCONTROLCONFIGSENSORPROVIDERENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_SENSOR_CONFIG_USE_PROVIDER_SSC_V02 = 0, /**<  Sensors data provider is Snapdragon Sensor Core (SSC);
+       this is the default
+   */
+  eQMI_LOC_SENSOR_CONFIG_USE_PROVIDER_NATIVE_V02 = 1, /**<  Sensors data provider is on the host processor  */
+  QMILOCSENSORSCONTROLCONFIGSENSORPROVIDERENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocSensorsControlConfigSensorProviderEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Sets the sensor control configuration. */
+typedef struct {
+
+  /* Optional */
+  /*  Sensors Usage */
+  uint8_t sensorsUsage_valid;  /**< Must be set to true if sensorsUsage is being passed */
+  qmiLocSensorsControlConfigSensorUseEnumT_v02 sensorsUsage;
+  /**<   Controls how sensors are used to aid heading and positioning
+ performance.
+
+ Valid values: \n
+      - eQMI_LOC_SENSOR_CONFIG_SENSOR_USE_ENABLE (0) --  Sensors data should be requested whenever a position request is
+       received. If sensor data are injected, the positioning engine
+       attempts to improve the heading and positioning performance using sensors.
+       This is the default.
+
+      - eQMI_LOC_SENSOR_CONFIG_SENSOR_USE_DISABLE (1) --  Inertial sensors are not to be used to aid heading and position
+       improvement.
+ */
+
+  /* Optional */
+  /*  Sensors Provider */
+  uint8_t sensorProvider_valid;  /**< Must be set to true if sensorProvider is being passed */
+  qmiLocSensorsControlConfigSensorProviderEnumT_v02 sensorProvider;
+  /**<   Controls which sensors data provider is to be used.
+
+ Valid values: \n
+      - eQMI_LOC_SENSOR_CONFIG_USE_PROVIDER_SSC (0) --  Sensors data provider is Snapdragon Sensor Core (SSC);
+       this is the default
+
+      - eQMI_LOC_SENSOR_CONFIG_USE_PROVIDER_NATIVE (1) --  Sensors data provider is on the host processor
+ */
+}qmiLocSetSensorControlConfigReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Sets the sensor control configuration. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Set Sensor Control Config Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Set Sensor Control Configuration request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+}qmiLocSetSensorControlConfigIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Retrieves the current sensor control configuration. */
+typedef struct {
+  /* This element is a placeholder to prevent the declaration of
+     an empty struct.  DO NOT USE THIS FIELD UNDER ANY CIRCUMSTANCE */
+  char __placeholder;
+}qmiLocGetSensorControlConfigReqMsgT_v02;
+
+  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Retrieves the current sensor control configuration. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Get Sensor Control Config Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Get Sensors Control Configuration request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Optional */
+  /*  Sensors Usage */
+  uint8_t sensorsUsage_valid;  /**< Must be set to true if sensorsUsage is being passed */
+  qmiLocSensorsControlConfigSensorUseEnumT_v02 sensorsUsage;
+  /**<   Controls how sensors are used to aid the heading and positioning
+ performance.
+
+ Valid values: \n
+      - eQMI_LOC_SENSOR_CONFIG_SENSOR_USE_ENABLE (0) --  Sensors data should be requested whenever a position request is
+       received. If sensor data are injected, the positioning engine
+       attempts to improve the heading and positioning performance using sensors.
+       This is the default.
+
+      - eQMI_LOC_SENSOR_CONFIG_SENSOR_USE_DISABLE (1) --  Inertial sensors are not to be used to aid heading and position
+       improvement.
+ */
+
+  /* Optional */
+  /*  Sensors Provider */
+  uint8_t sensorProvider_valid;  /**< Must be set to true if sensorProvider is being passed */
+  qmiLocSensorsControlConfigSensorProviderEnumT_v02 sensorProvider;
+  /**<   Controls which sensors data provider to be used.
+
+ Valid values: \n
+      - eQMI_LOC_SENSOR_CONFIG_USE_PROVIDER_SSC (0) --  Sensors data provider is Snapdragon Sensor Core (SSC);
+       this is the default
+
+      - eQMI_LOC_SENSOR_CONFIG_USE_PROVIDER_NATIVE (1) --  Sensors data provider is on the host processor
+ */
+}qmiLocGetSensorControlConfigIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+typedef uint32_t qmiLocSensorPropertiesMaskT_v02;
+#define QMI_LOC_SENSOR_PROPERTIES_MASK_GYRO_BIAS_VARIANCE_RANDOM_WALK_V02 ((qmiLocSensorPropertiesMaskT_v02)0x00000001) /**<  Denotes the gyro bias variance random walk parameter  */
+#define QMI_LOC_SENSOR_PROPERTIES_MASK_VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_V02 ((qmiLocSensorPropertiesMaskT_v02)0x00000002) /**<  Denotes the velocity random walk spectral density parameter  */
+#define QMI_LOC_SENSOR_PROPERTIES_MASK_ACCELERATION_RANDOM_WALK_SPECTRAL_DENSITY_V02 ((qmiLocSensorPropertiesMaskT_v02)0x00000004) /**<  Denotes the acceleration random walk spectral density parameter  */
+#define QMI_LOC_SENSOR_PROPERTIES_MASK_ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_V02 ((qmiLocSensorPropertiesMaskT_v02)0x00000008) /**<  Denotes the angle random walk spectral density parameter  */
+#define QMI_LOC_SENSOR_PROPERTIES_MASK_RATE_RANDOM_WALK_SPECTRAL_DENSITY_V02 ((qmiLocSensorPropertiesMaskT_v02)0x00000010) /**<  Denotes the rate random walk spectral density parameter  */
+#define QMI_LOC_SENSOR_PROPERTIES_MASK_VEHICLE_DATA_USE_CONTROL_V02 ((qmiLocSensorPropertiesMaskT_v02)0x00000020) /**<  Denotes the vehicle data use control parameter  */
+#define QMI_LOC_SENSOR_PROPERTIES_MASK_VEHICLE_VELOCITY_RWSD_V02 ((qmiLocSensorPropertiesMaskT_v02)0x00000040) /**<  Denotes the vehicle velocity random walk spectral density  */
+#define QMI_LOC_SENSOR_PROPERTIES_MASK_VEHICLE_ACCEL_RWSD_V02 ((qmiLocSensorPropertiesMaskT_v02)0x00000080) /**<  Denotes the vehicle accelerometer random walk spectral density  */
+#define QMI_LOC_SENSOR_PROPERTIES_MASK_VEHICLE_ANGLE_RWSD_V02 ((qmiLocSensorPropertiesMaskT_v02)0x00000100) /**<  Denotes the vehicle angle random walk spectral density   */
+#define QMI_LOC_SENSOR_PROPERTIES_MASK_VEHICLE_ANGULAR_RATE_RWSD_V02 ((qmiLocSensorPropertiesMaskT_v02)0x00000200) /**<  Denotes the vehicle angular rate random walk spectral density   */
+#define QMI_LOC_SENSOR_PROPERTIES_MASK_VEHICLE_ODOMETRY_SCALE_RWSD_V02 ((qmiLocSensorPropertiesMaskT_v02)0x00000400) /**<  Denotes the vehicle odometry scale random walk spectral density   */
+#define QMI_LOC_SENSOR_PROPERTIES_MASK_VEHICLE_ODOMETRY_VARIANCE_V02 ((qmiLocSensorPropertiesMaskT_v02)0x00000800) /**<  Denotes the vehicle odometry variance   */
+typedef uint64_t qmiLocVehicleDataUseControlMaskT_v02;
+#define QMI_LOC_VEHICLE_DATA_ENABLE_USE_MASK_ACCEL_X_AXIS_V02 ((qmiLocVehicleDataUseControlMaskT_v02)0x0000000000000001ull) /**<  Enable use of X-axis vehicle acceleration sensor data  */
+#define QMI_LOC_VEHICLE_DATA_ENABLE_USE_MASK_ACCEL_Y_AXIS_V02 ((qmiLocVehicleDataUseControlMaskT_v02)0x0000000000000002ull) /**<  Enable use of Y-axis vehicle acceleration sensor data  */
+#define QMI_LOC_VEHICLE_DATA_ENABLE_USE_MASK_ACCEL_Z_AXIS_V02 ((qmiLocVehicleDataUseControlMaskT_v02)0x0000000000000004ull) /**<  Enable use of Z-axis vehicle acceleration sensor data  */
+#define QMI_LOC_VEHICLE_DATA_ENABLE_USE_MASK_GYRO_X_AXIS_V02 ((qmiLocVehicleDataUseControlMaskT_v02)0x0000000000000010ull) /**<  Enable use of X-axis vehicle gyroscope data  */
+#define QMI_LOC_VEHICLE_DATA_ENABLE_USE_MASK_GYRO_Y_AXIS_V02 ((qmiLocVehicleDataUseControlMaskT_v02)0x0000000000000020ull) /**<  Enable use of Y-axis vehicle gyroscope data  */
+#define QMI_LOC_VEHICLE_DATA_ENABLE_USE_MASK_GYRO_Z_AXIS_V02 ((qmiLocVehicleDataUseControlMaskT_v02)0x0000000000000040ull) /**<  Enable use of Z-axis vehicle gyroscope data  */
+#define QMI_LOC_VEHICLE_DATA_ENABLE_USE_MASK_ODOMETRY_V02 ((qmiLocVehicleDataUseControlMaskT_v02)0x0000000000000100ull) /**<  Enable use of odometry data  */
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Sets the properties specific to the type of sensor used.
+                    The control point must set sensor properties before they can be
+                    used to aid in heading and positioning performance improvement.
+   */
+typedef struct {
+
+  /* Optional */
+  /*  Gyro Bias Random Walk Variance */
+  uint8_t gyroBiasVarianceRandomWalk_valid;  /**< Must be set to true if gyroBiasVarianceRandomWalk is being passed */
+  float gyroBiasVarianceRandomWalk;
+  /**<   Specifies the gyro bias random walk variance parameter as a positive
+       floating-point value. This value has internal default value 1.0e-5 radian^2/second^4.
+       The gyro bias variance random walk parameter is derived from either the
+       sensors data sheet or a sensors conformance test. \n
+       - Units: Radians^2/seconds^4
+
+  */
+
+  /* Optional */
+  /*  Velocity Random Walk Spectral Density */
+  uint8_t velocityRandomWalkSpectralDensity_valid;  /**< Must be set to true if velocityRandomWalkSpectralDensity is being passed */
+  float velocityRandomWalkSpectralDensity;
+  /**<   Specifies the velocity random walk spectral density parameter as a positive
+       floating-point value. This value does not have any internal defaults.
+       The velocity random walk spectral density parameter is derived from either the
+       sensors data sheet or a sensors conformance test. \n
+       - Units: Meters/seconds^2/Hertz^0.5
+
+  */
+
+  /* Optional */
+  /*  Acceleration Random Walk Spectral Density */
+  uint8_t accelerationRandomWalkSpectralDensity_valid;  /**< Must be set to true if accelerationRandomWalkSpectralDensity is being passed */
+  float accelerationRandomWalkSpectralDensity;
+  /**<   Specifies the acceleration random walk spectral density parameter as a positive
+       floating-point value. This value does not have any internal defaults.
+       The acceleration random walk spectral density parameter is derived from either the
+       sensors data sheet or a sensors conformance test. \n
+       - Units: Meters/seconds^3/Hertz^0.5
+
+  */
+
+  /* Optional */
+  /*  Angle Random Walk Spectral Density */
+  uint8_t angleRandomWalkSpectralDensity_valid;  /**< Must be set to true if angleRandomWalkSpectralDensity is being passed */
+  float angleRandomWalkSpectralDensity;
+  /**<   Specifies the angle random walk spectral density parameter as a positive
+       floating-point value. This value does not have any internal defaults.
+       The angle random walk spectral density parameter is derived from either the
+       sensors data sheet or a sensors conformance test. \n
+       - Units: Radians/seconds/Hertz^0.5
+
+  */
+
+  /* Optional */
+  /*  Rate Random Walk Spectral Density */
+  uint8_t rateRandomWalkSpectralDensity_valid;  /**< Must be set to true if rateRandomWalkSpectralDensity is being passed */
+  float rateRandomWalkSpectralDensity;
+  /**<   Specifies the rate random walk spectral density parameter as a positive
+       floating-point value. This value does not have any internal defaults.
+       The rate random walk spectral density parameter is derived from either the
+       sensors data sheet or a sensors conformance test. \n
+       - Units: Radians/seconds^2/Hertz^0.5
+
+  */
+
+  /* Optional */
+  /*  Vehicle Data Use Control */
+  uint8_t vehicleDataUse_valid;  /**< Must be set to true if vehicleDataUse is being passed */
+  qmiLocVehicleDataUseControlMaskT_v02 vehicleDataUse;
+  /**<   Identifies which portions of the vehicle data to use in location
+ estimation (information provided by the message
+ QMI_LOC_INJECT_VEHICLE_SENSOR_DATA). Valid bitmasks: \n
+      - QMI_LOC_VEHICLE_DATA_ENABLE_USE_MASK_ACCEL_X_AXIS (0x0000000000000001) --  Enable use of X-axis vehicle acceleration sensor data
+      - QMI_LOC_VEHICLE_DATA_ENABLE_USE_MASK_ACCEL_Y_AXIS (0x0000000000000002) --  Enable use of Y-axis vehicle acceleration sensor data
+      - QMI_LOC_VEHICLE_DATA_ENABLE_USE_MASK_ACCEL_Z_AXIS (0x0000000000000004) --  Enable use of Z-axis vehicle acceleration sensor data
+      - QMI_LOC_VEHICLE_DATA_ENABLE_USE_MASK_GYRO_X_AXIS (0x0000000000000010) --  Enable use of X-axis vehicle gyroscope data
+      - QMI_LOC_VEHICLE_DATA_ENABLE_USE_MASK_GYRO_Y_AXIS (0x0000000000000020) --  Enable use of Y-axis vehicle gyroscope data
+      - QMI_LOC_VEHICLE_DATA_ENABLE_USE_MASK_GYRO_Z_AXIS (0x0000000000000040) --  Enable use of Z-axis vehicle gyroscope data
+      - QMI_LOC_VEHICLE_DATA_ENABLE_USE_MASK_ODOMETRY (0x0000000000000100) --  Enable use of odometry data
+ \b Note: All other bits are reserved for future use and are to be set to 0. */
+
+  /* Optional */
+  /*  Vehicle Velocity Random Walk Spectral Density */
+  uint8_t vehicleVelocityRandomWalkSpectralDensity_valid;  /**< Must be set to true if vehicleVelocityRandomWalkSpectralDensity is being passed */
+  float vehicleVelocityRandomWalkSpectralDensity;
+  /**<   Vehicle velocity random walk spectral density. \n
+       - Type: 32-bit float    \n
+       - Units: Meters/seconds^2/Hz^0.5     \n
+       - Valid values: Positive values  \n
+       - Default: None
+  */
+
+  /* Optional */
+  /*  Vehicle Acceleration Random Walk Spectral Density */
+  uint8_t vehicleAccelRandomWalkSpectralDensity_valid;  /**< Must be set to true if vehicleAccelRandomWalkSpectralDensity is being passed */
+  float vehicleAccelRandomWalkSpectralDensity;
+  /**<   Vehicle accelerometer random walk spectral density. \n
+       - Type: 32-bit float    \n
+       - Units: Meters/seconds^3/Hz^0.5     \n
+       - Valid values: Positive values  \n
+       - Default: None
+  */
+
+  /* Optional */
+  /*  Vehicle Angle Random Walk Spectral Density */
+  uint8_t vehicleAngleRandomWalkSpectralDensity_valid;  /**< Must be set to true if vehicleAngleRandomWalkSpectralDensity is being passed */
+  float vehicleAngleRandomWalkSpectralDensity;
+  /**<   Vehicle angle random walk spectral density. \n
+       - Type: 32-bit float    \n
+       - Units: Radians/seconds/Hz^0.5     \n
+       - Valid values: Positive values  \n
+       - Default: None
+  */
+
+  /* Optional */
+  /*  Vehicle Angular Rate Random Walk Spectral Density */
+  uint8_t vehicleAngularRateRandomWalkSpectralDensity_valid;  /**< Must be set to true if vehicleAngularRateRandomWalkSpectralDensity is being passed */
+  float vehicleAngularRateRandomWalkSpectralDensity;
+  /**<   Vehicle angular rate random walk spectral density. \n
+       - Type: 32-bit float    \n
+       - Units: Radians/seconds^2/Hz^0.5 \n
+       - Valid values: Positive values  \n
+       - Default: None
+  */
+
+  /* Optional */
+  /*  Vehicle Odometry Scale Factor Random Walk Spectral Density */
+  uint8_t vehicleOdometryScaleFactorRandomWalkSpectralDensity_valid;  /**< Must be set to true if vehicleOdometryScaleFactorRandomWalkSpectralDensity is being passed */
+  float vehicleOdometryScaleFactorRandomWalkSpectralDensity;
+  /**<   Vehicle odometry scale factor random walk spectral density. \n
+       - Type: 32-bit float    \n
+       - Units: (1/seconds)/Hz^0.5      \n
+       - Range: Approximately 0.0001 to 0.001 \n
+       - Default: 0.001 (actual calibration recommended)
+  */
+
+  /* Optional */
+  /*  Vehicle Odometry Variance */
+  uint8_t vehicleOdometryVariance_valid;  /**< Must be set to true if vehicleOdometryVariance is being passed */
+  float vehicleOdometryVariance;
+  /**<   Vehicle odometry variance of each odometry sample
+      (coarseness of measurement). \n
+       - Type: 32-bit float    \n
+       - Units: Meters^2    \n
+       - Valid values: Positive values  \n
+       - Default: None
+  */
+}qmiLocSetSensorPropertiesReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Sets the properties specific to the type of sensor used.
+                    The control point must set sensor properties before they can be
+                    used to aid in heading and positioning performance improvement.
+   */
+typedef struct {
+
+  /* Mandatory */
+  /*  Set Sensor Properties Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Set Sensor Properties request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure  */
+
+  /* Optional */
+  /*  Failed Set Sensor Properties */
+  uint8_t failedSensorPropertiesMask_valid;  /**< Must be set to true if failedSensorPropertiesMask is being passed */
+  qmiLocSensorPropertiesMaskT_v02 failedSensorPropertiesMask;
+  /**<   This field is sent only if the status is not SUCCESS.
+ Identifies the parameters that were not set successfully.
+
+ Valid bitmasks:
+      - QMI_LOC_SENSOR_PROPERTIES_MASK_GYRO_BIAS_VARIANCE_RANDOM_WALK (0x00000001) --  Denotes the gyro bias variance random walk parameter
+      - QMI_LOC_SENSOR_PROPERTIES_MASK_VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY (0x00000002) --  Denotes the velocity random walk spectral density parameter
+      - QMI_LOC_SENSOR_PROPERTIES_MASK_ACCELERATION_RANDOM_WALK_SPECTRAL_DENSITY (0x00000004) --  Denotes the acceleration random walk spectral density parameter
+      - QMI_LOC_SENSOR_PROPERTIES_MASK_ANGLE_RANDOM_WALK_SPECTRAL_DENSITY (0x00000008) --  Denotes the angle random walk spectral density parameter
+      - QMI_LOC_SENSOR_PROPERTIES_MASK_RATE_RANDOM_WALK_SPECTRAL_DENSITY (0x00000010) --  Denotes the rate random walk spectral density parameter
+      - QMI_LOC_SENSOR_PROPERTIES_MASK_VEHICLE_DATA_USE_CONTROL (0x00000020) --  Denotes the vehicle data use control parameter
+      - QMI_LOC_SENSOR_PROPERTIES_MASK_VEHICLE_VELOCITY_RWSD (0x00000040) --  Denotes the vehicle velocity random walk spectral density
+      - QMI_LOC_SENSOR_PROPERTIES_MASK_VEHICLE_ACCEL_RWSD (0x00000080) --  Denotes the vehicle accelerometer random walk spectral density
+      - QMI_LOC_SENSOR_PROPERTIES_MASK_VEHICLE_ANGLE_RWSD (0x00000100) --  Denotes the vehicle angle random walk spectral density
+      - QMI_LOC_SENSOR_PROPERTIES_MASK_VEHICLE_ANGULAR_RATE_RWSD (0x00000200) --  Denotes the vehicle angular rate random walk spectral density
+      - QMI_LOC_SENSOR_PROPERTIES_MASK_VEHICLE_ODOMETRY_SCALE_RWSD (0x00000400) --  Denotes the vehicle odometry scale random walk spectral density
+      - QMI_LOC_SENSOR_PROPERTIES_MASK_VEHICLE_ODOMETRY_VARIANCE (0x00000800) --  Denotes the vehicle odometry variance
+ \vspace{-0.18in} \end{itemize1}
+ */
+}qmiLocSetSensorPropertiesIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Retrieves the current sensor properties. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Sensor Properties Config Parameters */
+  qmiLocSensorPropertiesMaskT_v02 getSensorPropertiesMask;
+  /**<   Mask denoting the sensor properties parameters to be retrieved.
+
+ Valid bitmasks:
+      - QMI_LOC_SENSOR_PROPERTIES_MASK_GYRO_BIAS_VARIANCE_RANDOM_WALK (0x00000001) --  Denotes the gyro bias variance random walk parameter
+      - QMI_LOC_SENSOR_PROPERTIES_MASK_VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY (0x00000002) --  Denotes the velocity random walk spectral density parameter
+      - QMI_LOC_SENSOR_PROPERTIES_MASK_ACCELERATION_RANDOM_WALK_SPECTRAL_DENSITY (0x00000004) --  Denotes the acceleration random walk spectral density parameter
+      - QMI_LOC_SENSOR_PROPERTIES_MASK_ANGLE_RANDOM_WALK_SPECTRAL_DENSITY (0x00000008) --  Denotes the angle random walk spectral density parameter
+      - QMI_LOC_SENSOR_PROPERTIES_MASK_RATE_RANDOM_WALK_SPECTRAL_DENSITY (0x00000010) --  Denotes the rate random walk spectral density parameter
+      - QMI_LOC_SENSOR_PROPERTIES_MASK_VEHICLE_DATA_USE_CONTROL (0x00000020) --  Denotes the vehicle data use control parameter
+      - QMI_LOC_SENSOR_PROPERTIES_MASK_VEHICLE_VELOCITY_RWSD (0x00000040) --  Denotes the vehicle velocity random walk spectral density
+      - QMI_LOC_SENSOR_PROPERTIES_MASK_VEHICLE_ACCEL_RWSD (0x00000080) --  Denotes the vehicle accelerometer random walk spectral density
+      - QMI_LOC_SENSOR_PROPERTIES_MASK_VEHICLE_ANGLE_RWSD (0x00000100) --  Denotes the vehicle angle random walk spectral density
+      - QMI_LOC_SENSOR_PROPERTIES_MASK_VEHICLE_ANGULAR_RATE_RWSD (0x00000200) --  Denotes the vehicle angular rate random walk spectral density
+      - QMI_LOC_SENSOR_PROPERTIES_MASK_VEHICLE_ODOMETRY_SCALE_RWSD (0x00000400) --  Denotes the vehicle odometry scale random walk spectral density
+      - QMI_LOC_SENSOR_PROPERTIES_MASK_VEHICLE_ODOMETRY_VARIANCE (0x00000800) --  Denotes the vehicle odometry variance
+ */
+}qmiLocGetSensorPropertiesReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Retrieves the current sensor properties. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Get Sensor Properties Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Get Sensors Properties request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Optional */
+  /*  Gyro Bias Random Walk Variance */
+  uint8_t gyroBiasVarianceRandomWalk_valid;  /**< Must be set to true if gyroBiasVarianceRandomWalk is being passed */
+  float gyroBiasVarianceRandomWalk;
+  /**<   Specifies the gyro bias random walk variance parameter as a positive
+       floating-point value. This value has internal default value 1.0e-5 radian^2/second^4.
+       The gyro bias variance random walk parameter is derived from either the
+       sensors data sheet or a sensors conformance test. \n
+       - Units: Radians^2/seconds^4
+
+  */
+
+  /* Optional */
+  /*  Velocity Random Walk Spectral Density */
+  uint8_t velocityRandomWalkSpectralDensity_valid;  /**< Must be set to true if velocityRandomWalkSpectralDensity is being passed */
+  float velocityRandomWalkSpectralDensity;
+  /**<   Specifies the velocity random walk spectral density parameter as a positive
+       floating-point value. This value does not have any internal defaults.
+       The velocity random walk spectral density parameter is derived from either the
+       sensors data sheet or a sensors conformance test. \n
+       - Units: Meters/seconds^2/Hertz^0.5
+
+  */
+
+  /* Optional */
+  /*  Acceleration Random Walk Spectral Density */
+  uint8_t accelerationRandomWalkSpectralDensity_valid;  /**< Must be set to true if accelerationRandomWalkSpectralDensity is being passed */
+  float accelerationRandomWalkSpectralDensity;
+  /**<   Specifies the acceleration random walk spectral density parameter as a positive
+       floating-point value. This value does not have any internal defaults.
+       The acceleration random walk spectral density parameter is derived from either the
+       sensors data sheet or a sensors conformance test. \n
+       - Units: Meters/seconds^3/Hertz^0.5
+
+  */
+
+  /* Optional */
+  /*  Angle Random Walk Spectral Density */
+  uint8_t angleRandomWalkSpectralDensity_valid;  /**< Must be set to true if angleRandomWalkSpectralDensity is being passed */
+  float angleRandomWalkSpectralDensity;
+  /**<   Specifies the angle random walk spectral density parameter as a positive
+       floating-point value. This value does not have any internal defaults.
+       The angle random walk spectral density parameter is derived from either the
+       sensors data sheet or a sensors conformance test. \n
+       - Units: Radians/seconds/Hertz^0.5
+
+  */
+
+  /* Optional */
+  /*  Rate Random Walk Spectral Density */
+  uint8_t rateRandomWalkSpectralDensity_valid;  /**< Must be set to true if rateRandomWalkSpectralDensity is being passed */
+  float rateRandomWalkSpectralDensity;
+  /**<   Specifies the rate random walk spectral density parameter as a positive
+       floating-point value. This value does not have any internal defaults.
+       The rate random walk spectral density parameter is derived from either the
+       sensors data sheet or a sensors conformance test. \n
+       - Units: Radians/seconds^2/Hertz^0.5
+
+  */
+
+  /* Optional */
+  /*  Vehicle Data Use Control */
+  uint8_t vehicleDataUse_valid;  /**< Must be set to true if vehicleDataUse is being passed */
+  qmiLocVehicleDataUseControlMaskT_v02 vehicleDataUse;
+  /**<   Identifies which portions of the vehicle data to use in location
+ estimation (information provided by message
+ QMI_LOC_INJECT_VEHICLE_SENSOR_DATA). Valid bitmasks: \n
+      - QMI_LOC_VEHICLE_DATA_ENABLE_USE_MASK_ACCEL_X_AXIS (0x0000000000000001) --  Enable use of X-axis vehicle acceleration sensor data
+      - QMI_LOC_VEHICLE_DATA_ENABLE_USE_MASK_ACCEL_Y_AXIS (0x0000000000000002) --  Enable use of Y-axis vehicle acceleration sensor data
+      - QMI_LOC_VEHICLE_DATA_ENABLE_USE_MASK_ACCEL_Z_AXIS (0x0000000000000004) --  Enable use of Z-axis vehicle acceleration sensor data
+      - QMI_LOC_VEHICLE_DATA_ENABLE_USE_MASK_GYRO_X_AXIS (0x0000000000000010) --  Enable use of X-axis vehicle gyroscope data
+      - QMI_LOC_VEHICLE_DATA_ENABLE_USE_MASK_GYRO_Y_AXIS (0x0000000000000020) --  Enable use of Y-axis vehicle gyroscope data
+      - QMI_LOC_VEHICLE_DATA_ENABLE_USE_MASK_GYRO_Z_AXIS (0x0000000000000040) --  Enable use of Z-axis vehicle gyroscope data
+      - QMI_LOC_VEHICLE_DATA_ENABLE_USE_MASK_ODOMETRY (0x0000000000000100) --  Enable use of odometry data
+ @note1 All other bits are reserved for future use and are to be set to 0. */
+
+  /* Optional */
+  /*  Vehicle Velocity Random Walk Spectral Density */
+  uint8_t vehicleVelocityRandomWalkSpectralDensity_valid;  /**< Must be set to true if vehicleVelocityRandomWalkSpectralDensity is being passed */
+  float vehicleVelocityRandomWalkSpectralDensity;
+  /**<   Vehicle velocity random walk spectral density. \n
+       - Type: 32-bit float    \n
+       - Units: Meters/seconds^2/Hz^0.5     \n
+       - Valid values: Positive values  \n
+       - Default: None
+  */
+
+  /* Optional */
+  /*  Vehicle Acceleration Random Walk Spectral Density */
+  uint8_t vehicleAccelRandomWalkSpectralDensity_valid;  /**< Must be set to true if vehicleAccelRandomWalkSpectralDensity is being passed */
+  float vehicleAccelRandomWalkSpectralDensity;
+  /**<   Vehicle accelerometer random walk spectral density. \n
+       - Type: 32-bit float    \n
+       - Units: Meters/seconds^3/Hz^0.5     \n
+       - Valid values: Positive values  \n
+       - Default: None
+  */
+
+  /* Optional */
+  /*  Vehicle Angle Random Walk Spectral Density */
+  uint8_t vehicleAngleRandomWalkSpectralDensity_valid;  /**< Must be set to true if vehicleAngleRandomWalkSpectralDensity is being passed */
+  float vehicleAngleRandomWalkSpectralDensity;
+  /**<   Vehicle angle random walk spectral density. \n
+       - Type: 32-bit float    \n
+       - Units: Radians/seconds/Hz^0.5     \n
+       - Valid values: Positive values  \n
+       - Default: None
+  */
+
+  /* Optional */
+  /*  Vehicle Angular Rate Random Walk Spectral Density */
+  uint8_t vehicleAngularRateRandomWalkSpectralDensity_valid;  /**< Must be set to true if vehicleAngularRateRandomWalkSpectralDensity is being passed */
+  float vehicleAngularRateRandomWalkSpectralDensity;
+  /**<   Vehicle angular rate random walk spectral density. \n
+       - Type: 32-bit float    \n
+       - Units: Radians/seconds^2/Hz^0.5 \n
+       - Valid values: Positive values  \n
+       - Default: None
+  */
+
+  /* Optional */
+  /*  Vehicle Odometry Scale Factor Random Walk Spectral Density */
+  uint8_t vehicleOdometryScaleFactorRandomWalkSpectralDensity_valid;  /**< Must be set to true if vehicleOdometryScaleFactorRandomWalkSpectralDensity is being passed */
+  float vehicleOdometryScaleFactorRandomWalkSpectralDensity;
+  /**<   Vehicle odometry scale factor random walk spectral density. \n
+       - Type: 32-bit float    \n
+       - Units: (1/seconds)/Hz^0.5      \n
+       - Range: Approximately 0.0001 to 0.001 \n
+       - Default: 0.001 (actual calibration recommended)
+  */
+
+  /* Optional */
+  /*  Vehicle Odometry Variance */
+  uint8_t vehicleOdometryVariance_valid;  /**< Must be set to true if vehicleOdometryVariance is being passed */
+  float vehicleOdometryVariance;
+  /**<   Vehicle odometry variance of each odometry sample
+      (coarseness of measurement). \n
+       - Type: 32-bit float    \n
+       - Units: Meters^2    \n
+       - Valid values: Positive values  \n
+       - Default: None
+  */
+}qmiLocGetSensorPropertiesIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCSENSORPERFORMANCECONTROLMODEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_SENSOR_PERFORMANCE_CONTROL_MODE_AUTO_V02 = 0, /**<  Sensors usage is to be determined by the GNSS location engine.
+       This mode can optimize power consumption and give a
+       power-balanced positioning and heading enhancement using
+       inertial sensors  */
+  eQMI_LOC_SENSOR_PERFORMANCE_CONTROL_MODE_FORCED_V02 = 1, /**<  Sensors usage is to be forced ON.
+       This mode can be requested by the control point when
+       power consumption is not a restriction to the use of
+       inertial sensors.  */
+  QMILOCSENSORPERFORMANCECONTROLMODEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocSensorPerformanceControlModeEnumT_v02;
+/**
+    @}
+  */
+
+typedef uint32_t qmiLocSensorAlgorithmMaskT_v02;
+#define QMI_LOC_SENSOR_ALGORITHM_MASK_DISABLE_INS_POSITIONING_FILTER_V02 ((qmiLocSensorAlgorithmMaskT_v02)0x00000001) /**<  Inertial sensors are not to be used in Accelerometer-integrated fashion with
+       GNSS. They can still be used for aiding in heading improvements.  */
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Provides fine-grained control of sensor based positioning
+                    performance. */
+typedef struct {
+
+  /* Optional */
+  /*  Sensor Performance Control Mode */
+  uint8_t performanceControlMode_valid;  /**< Must be set to true if performanceControlMode is being passed */
+  qmiLocSensorPerformanceControlModeEnumT_v02 performanceControlMode;
+  /**<   Controls when sensors data is requested during GNSS fix processing.
+ This field is relevant only when sensors have been enabled using the
+ sensors control configuration.
+
+ Valid values: \n
+      - eQMI_LOC_SENSOR_PERFORMANCE_CONTROL_MODE_AUTO (0) --  Sensors usage is to be determined by the GNSS location engine.
+       This mode can optimize power consumption and give a
+       power-balanced positioning and heading enhancement using
+       inertial sensors
+      - eQMI_LOC_SENSOR_PERFORMANCE_CONTROL_MODE_FORCED (1) --  Sensors usage is to be forced ON.
+       This mode can be requested by the control point when
+       power consumption is not a restriction to the use of
+       inertial sensors.
+ */
+
+  /* Optional */
+  /*  Accelerometer Sampling Specification */
+  uint8_t accelSamplingSpec_valid;  /**< Must be set to true if accelSamplingSpec is being passed */
+  qmiLocSensorControlConfigSamplingSpecStructT_v02 accelSamplingSpec;
+  /**<   \vspace{0.06in} \n Sets the nominal rate at which the GNSS location
+       engine is to request acceleration data to be used by the low data rate
+       filter. The sensor data rate is specified in terms of the nominal number
+       of samples per batch and the number of batches per second.
+       However, the final control of the actual requested rate resides with
+       the Sensors Manager Module/GNSS location engine. \n
+       Default: 10 Hz sampling rate and 2 Hz batching rate.
+  */
+
+  /* Optional */
+  /*  Gyroscope Sampling Specification */
+  uint8_t gyroSamplingSpec_valid;  /**< Must be set to true if gyroSamplingSpec is being passed */
+  qmiLocSensorControlConfigSamplingSpecStructT_v02 gyroSamplingSpec;
+  /**<   \vspace{0.06in} \n Sets the nominal rate at which the GNSS location
+       engine is to request gyro data to be used by the high data rate filter.
+       The sensor data rate is specified in terms of the nominal number of
+       samples per batch and the number of batches per second.
+       However, the final control of the actual requested rate resides with
+       the Sensors Manager Module/GNSS location engine. \n
+       Default: 10 Hz sampling rate and 2 Hz batching rate.
+  */
+
+  /* Optional */
+  /*  Algorithm Configuration */
+  uint8_t algorithmConfig_valid;  /**< Must be set to true if algorithmConfig is being passed */
+  qmiLocSensorAlgorithmMaskT_v02 algorithmConfig;
+  /**<   Sets which sensor algorithms are to be used when processing sensor data.
+
+       Valid bitmasks: \begin{itemize1}
+       \item    0x00000001 -- DISABLE_INS_ POSITIONING_FILTER
+       \vspace{-0.18in} \end{itemize1}
+  */
+
+  /* Optional */
+  /*  High Data Rate Filter Accelerometer Sampling Specification */
+  uint8_t accelSamplingSpecHigh_valid;  /**< Must be set to true if accelSamplingSpecHigh is being passed */
+  qmiLocSensorControlConfigSamplingSpecStructT_v02 accelSamplingSpecHigh;
+  /**<   \vspace{0.06in} \n Sets the nominal rate at which the GNSS location engine is to request
+       acceleration data to be used by the high data rate filter. The sensor
+       data rate is specified in terms of the nominal number of samples per
+       batch and the number of batches per second.
+       However, the final control of the actual requested rate resides with
+       the Sensors Manager Module/GNSS location engine. \n
+       Default: 100 Hz sampling rate and 4 Hz batching rate.
+  */
+
+  /* Optional */
+  /*  High Data Rate Filter Gyroscope Sampling Specification */
+  uint8_t gyroSamplingSpecHigh_valid;  /**< Must be set to true if gyroSamplingSpecHigh is being passed */
+  qmiLocSensorControlConfigSamplingSpecStructT_v02 gyroSamplingSpecHigh;
+  /**<   \vspace{0.06in} \n Sets the nominal rate at which the GNSS location engine is to request
+       gyro data to be used by the high data rate filter. The sensor data rate
+       is specified in terms of the nominal number of samples per batch and the
+       number of batches per second.
+       However, the final control of the actual requested rate resides with
+       the Sensors Manager Module/GNSS location engine. \n
+       Default: 100 Hz sampling rate and 4 Hz batching rate.
+  */
+}qmiLocSetSensorPerformanceControlConfigReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+typedef uint32_t qmiLocSensorPerformanceControlConfigFailureMaskT_v02;
+#define QMI_LOC_SENSOR_PERFORMANCE_CONTROL_CONFIG_PARAM_MASK_PERFORMANCE_MODE_V02 ((qmiLocSensorPerformanceControlConfigFailureMaskT_v02)0x00000001) /**<  Failed to set the performance mode  */
+#define QMI_LOC_SENSOR_PERFORMANCE_CONTROL_CONFIG_PARAM_MASK_ACCEL_SAMPLING_SPEC_V02 ((qmiLocSensorPerformanceControlConfigFailureMaskT_v02)0x00000002) /**<  Failed to set the accelerometer sampling specification  */
+#define QMI_LOC_SENSOR_PERFORMANCE_CONTROL_CONFIG_PARAM_MASK_GYRO_SAMPLING_SPEC_V02 ((qmiLocSensorPerformanceControlConfigFailureMaskT_v02)0x00000004) /**<  Failed to set the gyroscope sampling specification  */
+#define QMI_LOC_SENSOR_PERFORMANCE_CONTROL_CONFIG_PARAM_MASK_ALGORITHM_CONFIG_V02 ((qmiLocSensorPerformanceControlConfigFailureMaskT_v02)0x00000008) /**<  Failed to set the algorithm configuration  */
+#define QMI_LOC_SENSOR_PERFORMANCE_CONTROL_CONFIG_PARAM_MASK_ACCEL_SAMPLING_SPEC_HIGH_V02 ((qmiLocSensorPerformanceControlConfigFailureMaskT_v02)0x00000010) /**<  Failed to set the accelerometer sampling specification  */
+#define QMI_LOC_SENSOR_PERFORMANCE_CONTROL_CONFIG_PARAM_MASK_GYRO_SAMPLING_SPEC_HIGH_V02 ((qmiLocSensorPerformanceControlConfigFailureMaskT_v02)0x00000020) /**<  Failed to set the gyroscope sampling specification  */
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Provides fine-grained control of sensor based positioning
+                    performance. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Set Sensor Perf Control Config Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Set Sensor Performance Control Configuration request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Optional */
+  /*  Failed Configuration */
+  uint8_t failedConfiguration_valid;  /**< Must be set to true if failedConfiguration is being passed */
+  qmiLocSensorPerformanceControlConfigFailureMaskT_v02 failedConfiguration;
+  /**<   Identifies parameters that were not configured successfully. This field
+       is sent only if the status is not a success.
+
+
+       Valid bitmasks: \begin{itemize1}
+       \item    0x00000001 -- PERFORMANCE_ MODE
+       \item    0x00000002 -- ACCEL_SAMPLING_ SPEC
+       \item    0x00000004 -- GYRO_SAMPLING_ SPEC
+       \item    0x00000008 -- ALGORITHM_ CONFIG
+       \item    0x00000010 -- ACCEL_SAMPLING_ SPEC_HIGH
+       \item    0x00000020 -- GYRO_SAMPLING_ SPEC_HIGH
+       \vspace{-0.18in} \end{itemize1}
+  */
+}qmiLocSetSensorPerformanceControlConfigIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Retrieves the current sensor performance control
+                    configuration. */
+typedef struct {
+  /* This element is a placeholder to prevent the declaration of
+     an empty struct.  DO NOT USE THIS FIELD UNDER ANY CIRCUMSTANCE */
+  char __placeholder;
+}qmiLocGetSensorPerformanceControlConfigReqMsgT_v02;
+
+  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Retrieves the current sensor performance control
+                    configuration. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Get Sensor Perf Control Config Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Get Sensor Performance Control Configuration request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Optional */
+  /*  Performance Control Mode */
+  uint8_t performanceControlMode_valid;  /**< Must be set to true if performanceControlMode is being passed */
+  qmiLocSensorPerformanceControlModeEnumT_v02 performanceControlMode;
+  /**<   Controls when sensor data is requested during GNSS fix processing.
+ This field is relevant only when sensors have been enabled using the
+ sensor control configuration.
+
+ Valid values: \n
+      - eQMI_LOC_SENSOR_PERFORMANCE_CONTROL_MODE_AUTO (0) --  Sensors usage is to be determined by the GNSS location engine.
+       This mode can optimize power consumption and give a
+       power-balanced positioning and heading enhancement using
+       inertial sensors
+      - eQMI_LOC_SENSOR_PERFORMANCE_CONTROL_MODE_FORCED (1) --  Sensors usage is to be forced ON.
+       This mode can be requested by the control point when
+       power consumption is not a restriction to the use of
+       inertial sensors.
+ */
+
+  /* Optional */
+  /*  Accelerometer Sampling Specification */
+  uint8_t accelSamplingSpec_valid;  /**< Must be set to true if accelSamplingSpec is being passed */
+  qmiLocSensorControlConfigSamplingSpecStructT_v02 accelSamplingSpec;
+  /**<   \vspace{0.06in} \n Sets the nominal rate at which the GNSS location engine is to request
+       acceleration data to be used by the high data rate filter. The sensor
+       data rate is specified in terms of the nominal number of samples per
+       batch and the number of batches per second.
+       However, the final control of the actual requested rate resides with
+       the Sensors Manager Module/GNSS location engine. \n
+       Default: 10 Hz sampling rate and 2 Hz batching rate.
+  */
+
+  /* Optional */
+  /*  Gyroscope Sampling Specification */
+  uint8_t gyroSamplingSpec_valid;  /**< Must be set to true if gyroSamplingSpec is being passed */
+  qmiLocSensorControlConfigSamplingSpecStructT_v02 gyroSamplingSpec;
+  /**<   \vspace{0.06in} \n Sets the nominal rate at which the GNSS location engine is to request
+       gyro data to be used by the high data rate filter. The sensor data
+       rate is specified in terms of the nominal number of samples per batch
+       and the number of batches per second.
+       However, the final control of the actual requested rate resides with
+       the Sensors Manager Module/GNSS location engine. \n
+       Default: 10 Hz sampling rate and 2 Hz batching rate.
+  */
+
+  /* Optional */
+  /*  Algorithm Configuration */
+  uint8_t algorithmConfig_valid;  /**< Must be set to true if algorithmConfig is being passed */
+  qmiLocSensorAlgorithmMaskT_v02 algorithmConfig;
+  /**<   Informs which sensor algorithms are currently set.
+
+       Valid bitmasks: \begin{itemize1}
+       \item    0x00000001 -- DISABLE_INS_ POSITIONING_FILTER
+       \vspace{-0.18in} \end{itemize1}
+  */
+
+  /* Optional */
+  /*  High Data Rate Filter Accelerometer Sampling Specification */
+  uint8_t accelSamplingSpecHigh_valid;  /**< Must be set to true if accelSamplingSpecHigh is being passed */
+  qmiLocSensorControlConfigSamplingSpecStructT_v02 accelSamplingSpecHigh;
+  /**<   \vspace{0.06in} \n Sets the nominal rate at which the GNSS location engine is to request
+       acceleration data to be used by the high data rate filter. The sensor
+       data rate is specified in terms of the nominal number of samples per
+       batch and the number of batches per second.
+       However, the final control of the actual requested rate resides with
+       the Sensors Manager Module/GNSS location engine. \n
+       Default: 100 Hz sampling rate and 4 Hz batching rate.
+  */
+
+  /* Optional */
+  /*  High Data Rate Filter Gyroscope Sampling Specification */
+  uint8_t gyroSamplingSpecHigh_valid;  /**< Must be set to true if gyroSamplingSpecHigh is being passed */
+  qmiLocSensorControlConfigSamplingSpecStructT_v02 gyroSamplingSpecHigh;
+  /**<   \vspace{0.06in} \n Sets the nominal rate at which the GNSS location engine is to request
+       gyro data to be used by the high data rate filter. The sensor data rate
+       is specified in terms of the nominal number of samples per batch and the
+       number of batches per second.
+       However, the final control of the actual requested rate resides with
+       the Sensors Manager Module/GNSS location engine. \n
+       Default: 100 Hz sampling rate and 4 Hz batching rate.
+  */
+}qmiLocGetSensorPerformanceControlConfigIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Injects a SUPL certificate to be used in AGNSS sessions. */
+typedef struct {
+
+  /* Mandatory */
+  /*  SUPL Certificate ID */
+  uint8_t suplCertId;
+  /**<   Certificate ID of the SUPL certificate. \n
+       - Units: Bytes \n
+       - Range: 0 to 9  */
+
+  /* Mandatory */
+  /*  SUPL Certificate Data */
+  uint32_t suplCertData_len;  /**< Must be set to # of elements in suplCertData */
+  uint8_t suplCertData[QMI_LOC_MAX_SUPL_CERT_LENGTH_V02];
+  /**<   SUPL certificate contents. \n
+       - Type: Array of bytes \n
+       - Maximum certificate size: 2000 bytes */
+}qmiLocInjectSuplCertificateReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Injects a SUPL certificate to be used in AGNSS sessions. */
+typedef struct {
+
+  /* Mandatory */
+  /*  SUPL Certificate Injection Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Inject SUPL Certificate request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+}qmiLocInjectSuplCertificateIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Deletes a SUPL certificate. */
+typedef struct {
+
+  /* Optional */
+  /*  SUPL Certificate ID */
+  uint8_t suplCertId_valid;  /**< Must be set to true if suplCertId is being passed */
+  uint8_t suplCertId;
+  /**<   Certificate ID of the SUPL certificate to be deleted. \n
+       - Units: Bytes \n
+       - Range: 0 to 9 \n
+       If suplCertId is not specified,
+       all SUPL certificates are deleted. */
+}qmiLocDeleteSuplCertificateReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Deletes a SUPL certificate. */
+typedef struct {
+
+  /* Mandatory */
+  /*  SUPL Certificate Deletion Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Delete SUPL Certificate request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+}qmiLocDeleteSuplCertificateIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+typedef uint32_t qmiLocPositionEngineConfigParamMaskT_v02;
+#define QMI_LOC_POSITION_ENGINE_CONFIG_PARAM_MASK_INJECTED_POSITION_CONTROL_V02 ((qmiLocPositionEngineConfigParamMaskT_v02)0x00000001) /**<  Denotes whether the position engine uses the
+       injected position in a direct position calculation.  */
+#define QMI_LOC_POSITION_ENGINE_CONFIG_PARAM_MASK_FILTER_SV_USAGE_V02 ((qmiLocPositionEngineConfigParamMaskT_v02)0x00000002) /**<  Denotes whether the position engine filters the
+       SV usage in the fix.  */
+#define QMI_LOC_POSITION_ENGINE_CONFIG_PARAM_MASK_STORE_ASSIST_DATA_V02 ((qmiLocPositionEngineConfigParamMaskT_v02)0x00000004) /**<  Denotes whether the position engine stores assistance data
+       in persistent memory.  */
+#define QMI_LOC_POSITION_ENGINE_CONFIG_PARAM_MASK_ENABLE_FASTER_TTFF_V02 ((qmiLocPositionEngineConfigParamMaskT_v02)0x00000008) /**<  Denotes whether the position engine stays on to optimize
+       the TTFF for the subsequent position fix.  */
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to configure position engine
+                    functionality. */
+typedef struct {
+
+  /* Optional */
+  /*  Injected Position Control */
+  uint8_t injectedPositionControl_valid;  /**< Must be set to true if injectedPositionControl is being passed */
+  uint8_t injectedPositionControl;
+  /**<   Controls how the injected position is used in the position engine.
+
+       Valid values: \begin{itemize1}
+       \item    0x01 (TRUE) -- Use the injected position in a direct position
+                               calculation
+       \item    0x00 (FALSE) -- Do not use the injected position in a direct
+                                position calculation
+       \end{itemize1}
+       The default value is TRUE.
+  */
+
+  /* Optional */
+  /*  Filter SV Usage */
+  uint8_t filterSvUsage_valid;  /**< Must be set to true if filterSvUsage is being passed */
+  uint8_t filterSvUsage;
+  /**<   Controls whether SV usage is filtered in a position fix.
+
+       Valid values: \begin{itemize1}
+       \item    0x01 (TRUE) -- Filter the usage of SVs in the fix
+       \item    0x00 (FALSE) -- Do not filter the usage of SVs in the fix
+       \end{itemize1}
+       The default value is FALSE.
+  */
+
+  /* Optional */
+  /*  Store Assist Data */
+  uint8_t storeAssistData_valid;  /**< Must be set to true if storeAssistData is being passed */
+  uint8_t storeAssistData;
+  /**<   Controls whether assistance data is to be stored in
+       persistent memory.
+
+       Valid values: \begin{itemize1}
+       \item    0x01 (TRUE) -- Store assistance data in persistent memory
+       \item    0x00 (FALSE) -- Do not store assistance data in persistent memory
+       \end{itemize1}
+       The default value is TRUE.
+  */
+
+  /* Optional */
+  /*  Enable Faster TTFF */
+  uint8_t enableFasterTTFF_valid;  /**< Must be set to true if enableFasterTTFF is being passed */
+  uint8_t enableFasterTTFF;
+  /**<   Allows the receiver to stay on after a position session in order to
+       collect information that will help reduce the Time To First Fix (TTFF)
+       when the next position request is made. The receiver will stay
+       on only if  the engine determines that it needs to collect some
+       information. The receiver will stay on for the duration needed to
+       collect the information.
+       If enabled, the clients may see a delay in receiving the Engine Off
+       event after the position session ends.
+
+       Valid values: \begin{itemize1}
+       \item    0x01 (TRUE) -- Allow the engine to stay on for reduced TTFF
+       \item    0x00 (FALSE) -- Do not allow the engine to stay on for reduced
+                               TTFF
+       \end{itemize1}
+       The default value is TRUE.*/
+}qmiLocSetPositionEngineConfigParametersReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to configure position engine
+                    functionality. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Set Position Engine Configuration Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Set Configuration Parameters request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Optional */
+  /*  Failed Parameters */
+  uint8_t failedPositionEngineConfigParamMask_valid;  /**< Must be set to true if failedPositionEngineConfigParamMask is being passed */
+  qmiLocPositionEngineConfigParamMaskT_v02 failedPositionEngineConfigParamMask;
+  /**<   Identifies the parameters that were not set successfully.
+ This field is sent only if the status is other than SUCCESS.
+
+ Valid bitmasks:\n
+      - QMI_LOC_POSITION_ENGINE_CONFIG_PARAM_MASK_INJECTED_POSITION_CONTROL (0x00000001) --  Denotes whether the position engine uses the
+       injected position in a direct position calculation.
+      - QMI_LOC_POSITION_ENGINE_CONFIG_PARAM_MASK_FILTER_SV_USAGE (0x00000002) --  Denotes whether the position engine filters the
+       SV usage in the fix.
+      - QMI_LOC_POSITION_ENGINE_CONFIG_PARAM_MASK_STORE_ASSIST_DATA (0x00000004) --  Denotes whether the position engine stores assistance data
+       in persistent memory.
+      - QMI_LOC_POSITION_ENGINE_CONFIG_PARAM_MASK_ENABLE_FASTER_TTFF (0x00000008) --  Denotes whether the position engine stays on to optimize
+       the TTFF for the subsequent position fix.
+ */
+}qmiLocSetPositionEngineConfigParametersIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to get the position engine
+                    configuration parameters. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Config Parameters */
+  qmiLocPositionEngineConfigParamMaskT_v02 getPositionEngineConfigParamMask;
+  /**<   Mask denoting the configuration parameters to be retrieved.
+
+ Valid bitmasks:
+      - QMI_LOC_POSITION_ENGINE_CONFIG_PARAM_MASK_INJECTED_POSITION_CONTROL (0x00000001) --  Denotes whether the position engine uses the
+       injected position in a direct position calculation.
+      - QMI_LOC_POSITION_ENGINE_CONFIG_PARAM_MASK_FILTER_SV_USAGE (0x00000002) --  Denotes whether the position engine filters the
+       SV usage in the fix.
+      - QMI_LOC_POSITION_ENGINE_CONFIG_PARAM_MASK_STORE_ASSIST_DATA (0x00000004) --  Denotes whether the position engine stores assistance data
+       in persistent memory.
+      - QMI_LOC_POSITION_ENGINE_CONFIG_PARAM_MASK_ENABLE_FASTER_TTFF (0x00000008) --  Denotes whether the position engine stays on to optimize
+       the TTFF for the subsequent position fix.
+ */
+}qmiLocGetPositionEngineConfigParametersReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to get the position engine
+                    configuration parameters. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Get Position Engine Configuration Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Get Configuration Parameters request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Optional */
+  /*  Injected Position Control */
+  uint8_t injectedPositionControl_valid;  /**< Must be set to true if injectedPositionControl is being passed */
+  uint8_t injectedPositionControl;
+  /**<   Specifies whether the injected position is used for a direct calculation
+       in the position engine.
+
+       Valid values: \begin{itemize1}
+       \item    0x01 (TRUE) -- The injected position is used in a direct
+                               position calculation
+       \item    0x00 (FALSE) -- The injected position is not used in a direct
+                                position calculation
+       \end{itemize1}
+       The default value is TRUE.
+  */
+
+  /* Optional */
+  /*  Filter SV Usage */
+  uint8_t filterSvUsage_valid;  /**< Must be set to true if filterSvUsage is being passed */
+  uint8_t filterSvUsage;
+  /**<   Specifies whether SV usage is filtered in a position fix.
+
+       Valid values: \begin{itemize1}
+       \item    0x01 (TRUE) -- SV usage is filtered in the fix
+       \item    0x00 (FALSE) -- SV usage is not filtered in the fix
+       \end{itemize1}
+       The default value is FALSE.
+  */
+
+  /* Optional */
+  /*  Store Assist Data */
+  uint8_t storeAssistData_valid;  /**< Must be set to true if storeAssistData is being passed */
+  uint8_t storeAssistData;
+  /**<   Specifies whether assistance data is stored in persistent memory.
+
+       Valid values: \begin{itemize1}
+       \item    0x01 (TRUE) -- Assistance data is stored in persistent memory
+       \item    0x00 (FALSE) -- Assistance data is not stored in persistent
+                                memory
+       \end{itemize1}
+       The default value is TRUE.
+  */
+
+  /* Optional */
+  /*  Enable Faster TTFF */
+  uint8_t enableFasterTTFF_valid;  /**< Must be set to true if enableFasterTTFF is being passed */
+  uint8_t enableFasterTTFF;
+  /**<   Allows the receiver to stay on after a position session in order to
+       collect information that will help reduce the TTFF
+       when the next position request is made. The receiver will stay
+       on only if  the engine determines that it needs to collect some
+       information. The receiver will stay on for the duration needed to
+       collect the information.
+       If enabled, the clients may see a delay in receiving the Engine Off
+       event after the position session ends.
+
+       Valid values: \begin{itemize1}
+       \item    0x01 (TRUE) -- Allow the engine to stay on for reduced TTFF
+       \item    0x00 (FALSE) -- Do not allow the engine to stay on for reduced
+                               TTFF
+       \end{itemize1}
+        The default value is TRUE.*/
+}qmiLocGetPositionEngineConfigParametersIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+typedef uint8_t qmiLocGeofenceBreachMaskT_v02;
+#define QMI_LOC_GEOFENCE_BREACH_ENTERING_MASK_V02 ((qmiLocGeofenceBreachMaskT_v02)0x01) /**<  If this mask is set, a breach event is reported
+       when the Geofence is entered  */
+#define QMI_LOC_GEOFENCE_BREACH_LEAVING_MASK_V02 ((qmiLocGeofenceBreachMaskT_v02)0x02) /**<  If this mask is set, a breach event is reported
+       when the Geofence is exited  */
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCGEOFENCERESPONSIVENESSENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_GEOFENCE_RESPONSIVENESS_LOW_V02 = 0x01, /**<  The Geofence is monitored for a breach at a
+       low rate of 15 minutes. The gap between the actual breach and
+       the time it is reported is higher. This
+       setting results in lower power usage.  */
+  eQMI_LOC_GEOFENCE_RESPONSIVENESS_MED_V02 = 0x02, /**<  The Geofence is monitored for a breach at a
+       medium rate of 2 minutes. This is the default setting.  */
+  eQMI_LOC_GEOFENCE_RESPONSIVENESS_HIGH_V02 = 0x03, /**<  The Geofence is monitored for a breach at a
+       high rate of 10 seconds. The gap between the actual breach and
+       the time it is reported is low. This results
+       in higher power usage.  */
+  eQMI_LOC_GEOFENCE_RESPONSIVENESS_ULTRA_HIGH_V02 = 0x04, /**<  The Geofence is monitored for a breach at a
+       very high rate of 1 second. The gap between the actual breach and
+       the time it is reported is very low. This results
+       in very high power usage. This setting must be avoided whenever
+       possible because of the drastic power implications.  */
+  eQMI_LOC_GEOFENCE_RESPONSIVENESS_CUSTOM_V02 = 0x05, /**<  The Geofence is monitored for a breach at a
+       user defined rate. The gap between the actual breach and
+       the time it is reported depends on the user setting. The power implication
+       is inversely proportional to the responsiveness value set by the user.
+       The higher the responsiveness value, the lower the power implications, and vice-versa.  */
+  QMILOCGEOFENCERESPONSIVENESSENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocGeofenceResponsivenessEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  double latitude;
+  /**<   Latitude of the center of the Geofence.*/
+
+  double longitude;
+  /**<   Longitude of the center of the Geofence.*/
+
+  uint32_t radius;
+  /**<   Radius of the circular Geofence in meters. */
+}qmiLocCircularGeofenceArgsStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCGEOFENCEPOSITIONENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_GEOFENCE_POSITION_INSIDE_V02 = 0x01, /**<  Position is inside a Geofence  */
+  eQMI_LOC_GEOFENCE_POSITION_OUTSIDE_V02 = 0x02, /**<  Position is outside a Geofence  */
+  QMILOCGEOFENCEPOSITIONENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocGeofencePositionEnumT_v02;
+/**
+    @}
+  */
+
+typedef uint8_t qmiLocGeofenceDwellTypeMaskT_v02;
+#define QMI_LOC_GEOFENCE_DWELL_TYPE_INSIDE_MASK_V02 ((qmiLocGeofenceDwellTypeMaskT_v02)0x01) /**<  If this mask is set, a dwell event is reported
+       when a user dwells inside the Geofence for a specified time  */
+#define QMI_LOC_GEOFENCE_DWELL_TYPE_OUTSIDE_MASK_V02 ((qmiLocGeofenceDwellTypeMaskT_v02)0x02) /**<  If this mask is set, a dwell event is reported
+       when a user dwells outside the Geofence for a specified time  */
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to add a circular Geofence. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Transaction ID */
+  uint32_t transactionId;
+  /**<   Identifies the transaction. The transaction ID
+       is returned in the Add Circular Geofence
+       indication. */
+
+  /* Mandatory */
+  /*  Circular Geofence Arguments */
+  qmiLocCircularGeofenceArgsStructT_v02 circularGeofenceArgs;
+
+  /* Mandatory */
+  /*  Breach Event Mask */
+  qmiLocGeofenceBreachMaskT_v02 breachMask;
+  /**<   Specifies the breach events in which the client is interested.
+
+       Valid values: \begin{itemize1}
+       \item    0x01 -- GEOFENCE_BREACH_ ENTERING_MASK
+       \item    0x02 -- GEOFENCE_BREACH_ LEAVING_MASK
+       \vspace{-0.18in} \end{itemize1} */
+
+  /* Mandatory */
+  /*  Include Position in Breach Event */
+  uint8_t includePosition;
+  /**<   Specifies whether the Geofence engine is to include the position
+       in a breach event.
+
+       Valid values: \begin{itemize1}
+       \item    0x01 (TRUE) -- Position will be reported with the breach event
+       \item    0x00 (FALSE) -- Position will not be reported with the breach
+                                event
+       \vspace{-0.18in} \end{itemize1} */
+
+  /* Optional */
+  /*  Responsiveness */
+  uint8_t responsiveness_valid;  /**< Must be set to true if responsiveness is being passed */
+  qmiLocGeofenceResponsivenessEnumT_v02 responsiveness;
+  /**<   Specifies the rate of detection for a Geofence breach.
+ This may impact the time lag between the actual breach event and
+ when it is reported. This parameter has power implications
+ and is to be fine-tuned to optimize power savings.
+
+ Valid values: \n
+      - eQMI_LOC_GEOFENCE_RESPONSIVENESS_LOW (0x01) --  The Geofence is monitored for a breach at a
+       low rate of 15 minutes. The gap between the actual breach and
+       the time it is reported is higher. This
+       setting results in lower power usage.
+      - eQMI_LOC_GEOFENCE_RESPONSIVENESS_MED (0x02) --  The Geofence is monitored for a breach at a
+       medium rate of 2 minutes. This is the default setting.
+      - eQMI_LOC_GEOFENCE_RESPONSIVENESS_HIGH (0x03) --  The Geofence is monitored for a breach at a
+       high rate of 10 seconds. The gap between the actual breach and
+       the time it is reported is low. This results
+       in higher power usage.
+      - eQMI_LOC_GEOFENCE_RESPONSIVENESS_ULTRA_HIGH (0x04) --  The Geofence is monitored for a breach at a
+       very high rate of 1 second. The gap between the actual breach and
+       the time it is reported is very low. This results
+       in very high power usage. This setting must be avoided whenever
+       possible because of the drastic power implications.
+      - eQMI_LOC_GEOFENCE_RESPONSIVENESS_CUSTOM (0x05) --  The Geofence is monitored for a breach at a
+       user defined rate. The gap between the actual breach and
+       the time it is reported depends on the user setting. The power implication
+       is inversely proportional to the responsiveness value set by the user.
+       The higher the responsiveness value, the lower the power implications, and vice-versa.
+ */
+
+  /* Optional */
+  /*  Confidence */
+  uint8_t confidence_valid;  /**< Must be set to true if confidence is being passed */
+  qmiLocGeofenceConfidenceEnumT_v02 confidence;
+  /**<   Given a breach event, the confidence determines the probability
+ that the breach happened at the Geofence boundary.
+ This parameter has power implications and
+ is to be fine-tuned to optimize power savings.
+
+ Valid values: \n
+      - eQMI_LOC_GEOFENCE_CONFIDENCE_LOW (0x01) --  Geofence engine indicates a breach with
+       low confidence; this setting results in lower
+       power usage, and it can impact the yield because
+       incorrect breach events may be sent
+      - eQMI_LOC_GEOFENCE_CONFIDENCE_MED (0x02) --  (Default) Geofence engine indicates a breach with
+       medium confidence
+      - eQMI_LOC_GEOFENCE_CONFIDENCE_HIGH (0x03) --  Geofence engine indicates a breach with
+       high confidence; this setting results in higher
+       power usage
+ */
+
+  /* Optional */
+  /*  Custom Responsiveness Value */
+  uint8_t customResponsivenessValue_valid;  /**< Must be set to true if customResponsivenessValue is being passed */
+  uint32_t customResponsivenessValue;
+  /**<   Specifies in seconds the user-defined rate of detection for a Geofence breach.
+       This may impact the time lag between the actual breach event and
+       when it is reported. The gap between the actual breach and
+       the time it is reported depends on the user setting. The power implication
+       is inversely proportional to the responsiveness value set by the user.
+       The higher the responsiveness value, the lower the power implications, and vice-versa.
+       If this field is set, the responsiveness is always treated
+       as eQMI_LOC_GEOFENCE_ RESPONSIVENESS_CUSTOM.
+       The minimum value supported in this field is 1 second, and the maximum value is 65535 seconds.
+       An error is returned if an attempt is made to set this to an unsupported value.
+       If this field is set, the responsiveness is always treated
+       as eQMI_LOC_GEOFENCE_ RESPONSIVENESS_CUSTOM, which means that the other responsiveness
+       types, such as eQMI_LOC_GEOFENCE _RESPONSIVENESS_LOW, eQMI_LOC_GEOFENCE_ RESPONSIVENESS_MEDIUM,
+       eQMI_LOC_GEOFENCE_ RESPONSIVENESS_HIGH, and eQMI_LOC_GEOFENCE_ RESPONSIVENESS_ULTRA_HIGH are all
+       disregarded.
+       If this field is not set, the responsiveness will be treated as
+       eQMI_LOC_GEOFENCE_ RESPONSIVENESS_LOW, eQMI_LOC_GEOFENCE_RESPONSIVENESS_MEDIUM,
+       eQMI_LOC_GEOFENCE_RESPONSIVENESS_HIGH, or eQMI_LOC_GEOFENCE_RESPONSIVENESS_ULTRA_HIGH.
+  */
+
+  /* Optional */
+  /*  Dwell Time of Geofence */
+  uint8_t dwellTime_valid;  /**< Must be set to true if dwellTime is being passed */
+  uint32_t dwellTime;
+  /**<   Dwell time is the time in seconds a user spends in the Geofence before a dwell
+       event is sent.
+  */
+
+  /* Optional */
+  /*  Geofence Dwell Type */
+  uint8_t dwellTypeMask_valid;  /**< Must be set to true if dwellTypeMask is being passed */
+  qmiLocGeofenceDwellTypeMaskT_v02 dwellTypeMask;
+  /**<   Type of dwell event in which the user is interested .
+
+ Valid values: \n
+      - QMI_LOC_GEOFENCE_DWELL_TYPE_INSIDE_MASK (0x01) --  If this mask is set, a dwell event is reported
+       when a user dwells inside the Geofence for a specified time
+      - QMI_LOC_GEOFENCE_DWELL_TYPE_OUTSIDE_MASK (0x02) --  If this mask is set, a dwell event is reported
+       when a user dwells outside the Geofence for a specified time
+ */
+}qmiLocAddCircularGeofenceReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to add a circular Geofence. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Add Circular Geofence Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Add Circular Geofence request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Optional */
+  /*  Transaction ID */
+  uint8_t transactionId_valid;  /**< Must be set to true if transactionId is being passed */
+  uint32_t transactionId;
+  /**<   Transaction ID that was specified in the Add Circular
+       Geofence request. This parameter will always be present
+       if the status field is set to SUCCESS. */
+
+  /* Optional */
+  /*  Geofence ID */
+  uint8_t geofenceId_valid;  /**< Must be set to true if geofenceId is being passed */
+  uint32_t geofenceId;
+  /**<   Geofence identifier allocated by the engine.
+       The client must include this identifier in all transactions
+       pertaining to this Geofence. */
+}qmiLocAddCircularGeofenceIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to delete a Geofence. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Geofence ID */
+  uint32_t geofenceId;
+  /**<   Identifier for the Geofence that is to be deleted. */
+
+  /* Mandatory */
+  /*  Transaction ID */
+  uint32_t transactionId;
+  /**<   Identifies the transaction. The transaction ID
+       is returned in the Delete Geofence
+       indication. */
+}qmiLocDeleteGeofenceReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to delete a Geofence. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Delete Geofence Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Delete Geofence request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Optional */
+  /*  Geofence ID */
+  uint8_t geofenceId_valid;  /**< Must be set to true if geofenceId is being passed */
+  uint32_t geofenceId;
+  /**<   Identifier for the Geofence that was deleted. */
+
+  /* Optional */
+  /*  Transaction ID */
+  uint8_t transactionId_valid;  /**< Must be set to true if transactionId is being passed */
+  uint32_t transactionId;
+  /**<   Transaction ID that was specified in the Delete
+       Geofence request. This parameter will always be present
+       if the status field is set to SUCCESS. */
+}qmiLocDeleteGeofenceIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCGEOFENCEORIGINENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_GEOFENCE_ORIGIN_NETWORK_V02 = 1, /**<  Geofence was initiated by a network-initiated client  */
+  eQMI_LOC_GEOFENCE_ORIGIN_DEVICE_V02 = 2, /**<  Geofence was initiated by the device  */
+  QMILOCGEOFENCEORIGINENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocGeofenceOriginEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCGEOFENCESTATEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_GEOFENCE_STATE_ACTIVE_V02 = 1, /**<  Geofence is being actively monitored  */
+  eQMI_LOC_GEOFENCE_STATE_SUSPEND_V02 = 2, /**<  Geofence monitoring is suspended  */
+  QMILOCGEOFENCESTATEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocGeofenceStateEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to query a Geofence. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Geofence ID */
+  uint32_t geofenceId;
+  /**<   Identifier for the Geofence that is to be queried. */
+
+  /* Mandatory */
+  /*  Transaction ID */
+  uint32_t transactionId;
+  /**<   Identifies the transaction. The transaction ID
+       is returned with the Query Geofence
+       indication. */
+}qmiLocQueryGeofenceReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to query a Geofence. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Query Geofence Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Query Geofence request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Optional */
+  /*  Geofence ID */
+  uint8_t geofenceId_valid;  /**< Must be set to true if geofenceId is being passed */
+  uint32_t geofenceId;
+  /**<   Identifier for the Geofence that was queried. */
+
+  /* Optional */
+  /*  Transaction ID */
+  uint8_t transactionId_valid;  /**< Must be set to true if transactionId is being passed */
+  uint32_t transactionId;
+  /**<   Transaction ID that was specified in the Query
+       Geofence request. This parameter will always be present
+       if the status field is set to SUCCESS. */
+
+  /* Optional */
+  /*  Geofence Origin */
+  uint8_t geofenceOrigin_valid;  /**< Must be set to true if geofenceOrigin is being passed */
+  qmiLocGeofenceOriginEnumT_v02 geofenceOrigin;
+  /**<   Originator of the Geofence.
+
+ Valid values: \n
+      - eQMI_LOC_GEOFENCE_ORIGIN_NETWORK (1) --  Geofence was initiated by a network-initiated client
+      - eQMI_LOC_GEOFENCE_ORIGIN_DEVICE (2) --  Geofence was initiated by the device
+ */
+
+  /* Optional */
+  /*  Position with Respect to Geofence */
+  uint8_t posWrtGeofence_valid;  /**< Must be set to true if posWrtGeofence is being passed */
+  qmiLocGeofencePositionEnumT_v02 posWrtGeofence;
+  /**<   Indicates if the client is currently inside or outside
+ the Geofence.
+
+ Valid values: \n
+      - eQMI_LOC_GEOFENCE_POSITION_INSIDE (0x01) --  Position is inside a Geofence
+      - eQMI_LOC_GEOFENCE_POSITION_OUTSIDE (0x02) --  Position is outside a Geofence
+ */
+
+  /* Optional */
+  /*  Circular Geofence Parameters */
+  uint8_t circularGeofenceArgs_valid;  /**< Must be set to true if circularGeofenceArgs is being passed */
+  qmiLocCircularGeofenceArgsStructT_v02 circularGeofenceArgs;
+
+  /* Optional */
+  /*  Geofence State */
+  uint8_t geofenceState_valid;  /**< Must be set to true if geofenceState is being passed */
+  qmiLocGeofenceStateEnumT_v02 geofenceState;
+  /**<   Specifies whether the Geofence is to be actively monitored.
+
+ Valid values: \n
+      - eQMI_LOC_GEOFENCE_STATE_ACTIVE (1) --  Geofence is being actively monitored
+      - eQMI_LOC_GEOFENCE_STATE_SUSPEND (2) --  Geofence monitoring is suspended
+ */
+}qmiLocQueryGeofenceIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+typedef uint32_t qmiLocMotionDetectionSourceMaskT_v02;
+#define QMI_LOC_MOTION_DETECTION_SOURCE_SENSORS_V02 ((qmiLocMotionDetectionSourceMaskT_v02)0x00000001) /**<  Sensors are used for motion detection  */
+#define QMI_LOC_MOTION_DETECTION_SOURCE_WIFI_V02 ((qmiLocMotionDetectionSourceMaskT_v02)0x00000002) /**<  Wi-Fi is used for motion detection  */
+#define QMI_LOC_MOTION_DETECTION_SOURCE_WWAN_V02 ((qmiLocMotionDetectionSourceMaskT_v02)0x00000004) /**<  Wireless WAN is used for motion detection  */
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCGEOFENCEMOTIONSTATESENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_GEOFENCE_MOTION_STATE_STATIONARY_V02 = 0, /**<  Motion state Stationary -- Handset is completely stationary  */
+  eQMI_LOC_GEOFENCE_MOTION_STATE_FIDDLE_V02 = 1, /**<  Motion state Fiddle -- Handset is not in motion but is being "fiddled" with  */
+  eQMI_LOC_GEOFENCE_MOTION_STATE_WALK_V02 = 2, /**<  Motion state Walk -- User is walking with the handset  */
+  eQMI_LOC_GEOFENCE_MOTION_STATE_RUN_V02 = 3, /**<  Motion state Run -- User is running with the handset  */
+  eQMI_LOC_GEOFENCE_MOTION_STATE_DRIVE_V02 = 4, /**<  Motion state Drive -- User is driving with the handset    */
+  QMILOCGEOFENCEMOTIONSTATESENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocGeofenceMotionStatesEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  qmiLocGeofenceMotionStatesEnumT_v02 motionState;
+  /**<   Motion state for which information is being configured. */
+
+  float motionStateSpeed;
+  /**<    Motion state speed in milliseconds.
+
+           These are positive floating values.
+           The state speed must be configured carefully. Very low speed
+           configuration for a state may result in missing Geofence
+           breaches in some scenarios.
+
+           Typical motion state speeds: \n
+           - Stationary speed -- 0 meters/sec
+           - Fiddle speed -- 0 meters/sec \n
+           - Walk speed -- 3 meters/sec    \n
+           - Run speed -- 8 meters/sec \n
+           - Drive speed -- 56 meters/sec
+  */
+}qmiLocGeofenceMotionStateConfigStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to set the Geofence engine configuration. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Transaction ID */
+  uint32_t transactionId;
+  /**<   Identifies the transaction. The transaction ID
+       is returned with the Set Geofence Configuration
+       indication. */
+
+  /* Optional */
+  /*  GNSS Unavailable Indication Timeout */
+  uint8_t gnssUnavailableIndicationTimeout_valid;  /**< Must be set to true if gnssUnavailableIndicationTimeout is being passed */
+  uint32_t gnssUnavailableIndicationTimeout;
+  /**<   In a bad GNSS environment, this is the timeout after which the Geofence
+       engine sends out a GNSS Unavailable indication. The GNSS Unavailable
+       indication is sent under the following conditions: \begin{itemize1}
+       \item If gnssUnavailableIndicationTimeout is less than
+             gnssPositionSessionTimeout, the GNSS
+             Unavailable timeout indication is sent after
+             gnssPositionSessionTimeout expires
+       \item If gnssPositionSessionTimeout is less than
+             gnssUnavailableIndicationTimeout, the
+             GNSS Unavailable timeout indication is sent after
+             gnssUnavailableIndicationTimeout expires
+        \vspace{-0.18in} \end{itemize1} */
+
+  /* Optional */
+  /*  Max Geofences */
+  uint8_t maxGeofences_valid;  /**< Must be set to true if maxGeofences is being passed */
+  uint32_t maxGeofences;
+  /**<   Identifies the maximum number of Geofences that can be supported by
+       the Geofence engine. If this number is less than the currently deployed
+       Geofences, this command fails.
+
+       If the command succeeds, the engine supports the maximum number of
+       Geofences requested, provided there is enough memory to support that
+       many Geofences. Increasing this value to a very large number in a
+       constrained memory environment might affect other modules negatively.
+       This value is determined by phone manufacturers. The default value
+       is 200. */
+
+  /* Optional */
+  /*  Enable Motion Detection Sources */
+  uint8_t enableMotionDetectionSources_valid;  /**< Must be set to true if enableMotionDetectionSources is being passed */
+  qmiLocMotionDetectionSourceMaskT_v02 enableMotionDetectionSources;
+  /**<   Identifies the sources that can be enabled for motion detection by
+ the Geofence engine. The sources of motion detection that are enabled
+ by the Geofence engine are dependent on the platform.
+ These sources can only be set once at boot time and they are not expected to be changed after that.
+ Any attempt to set the value of the motion detection sources at runtime results in an undefined behavior.
+ Valid values: \n
+      - QMI_LOC_MOTION_DETECTION_SOURCE_SENSORS (0x00000001) --  Sensors are used for motion detection
+      - QMI_LOC_MOTION_DETECTION_SOURCE_WIFI (0x00000002) --  Wi-Fi is used for motion detection
+      - QMI_LOC_MOTION_DETECTION_SOURCE_WWAN (0x00000004) --  Wireless WAN is used for motion detection  */
+
+  /* Optional */
+  /*  Enable Coarse Position Injection Usage */
+  uint8_t enableCpiUsage_valid;  /**< Must be set to true if enableCpiUsage is being passed */
+  uint8_t enableCpiUsage;
+  /**<   Indicates whether external Coarse Position Injection (CPI) is used
+       by the Geofence engine.
+       \begin{itemize1}
+       \item    0x01 (TRUE)  -- CPI is enabled (default)
+       \item    0x00 (FALSE) -- CPI is disabled
+       \vspace{-0.18in} \end{itemize1}*/
+
+  /* Optional */
+  /*  GNSS Position QOS Session Timeout */
+  uint8_t gnssPositionSessionTimeout_valid;  /**< Must be set to true if gnssPositionSessionTimeout is being passed */
+  uint32_t gnssPositionSessionTimeout;
+  /**<   Identifies the session timeout value (in seconds) for requesting a
+         position in a bad GNSS environment.
+
+         Valid values: \begin{itemize1}
+   \item If the gnssUnavailableIndicationTimeout value is less than
+         gnssPositionSessionTimeout, in a bad GNSS environment, the GNSS
+         Unavailable timeout indication is sent after
+         gnssPositionSessionTimeout expires.
+   \item If gnssPositionSessionTimeout is less than gnssUnavailableIndicationTimeout,
+         in a bad GNSS environment, the GNSS Unavailable timeout indication
+         is sent after gnssUnavailableIndicationTimeout expires. \vspace{-0.18in} \end{itemize1}
+    */
+
+  /* Optional */
+  /*  GNSS Position Maximum Position Uncertainity Acceptable */
+  uint8_t gnssPositionMaxPuncAcceptable_valid;  /**< Must be set to true if gnssPositionMaxPuncAcceptable is being passed */
+  uint32_t gnssPositionMaxPuncAcceptable;
+  /**<   GNSS maximum position uncertainity in meters acceptable by
+         the Geofence engine.
+
+         Valid values: \n
+         - All positive values
+    */
+
+  /* Optional */
+  /*  Medium Responsiveness Value */
+  uint8_t mediumResponsivenessValue_valid;  /**< Must be set to true if mediumResponsivenessValue is being passed */
+  uint32_t mediumResponsivenessValue;
+  /**<   Medium responsiveness value in seconds that the Geofence engine
+         uses for all medium responsiveness Geofences in the Geofence engine.
+
+         Valid values: \begin{itemize1}
+         \item Positive values (in seconds)
+         \item If the value is configured for less than 30 sec, the value is
+               set at 30 sec
+         \item If the value is configured for more than 600 sec, the value is
+               set at 600 sec
+         \item Default -- The Geofence engine uses 120 sec as the medium
+                          responsiveness value
+         \end{itemize1}
+
+         If the medium responsiveness value is changed, the responsiveness
+         of the existing medium responsiveness Geofence does not change until the next
+         position fix, which is based on the previous medium responsiveness
+         setting.
+    */
+
+  /* Optional */
+  /*  Challenging GNSS Environment Minimum CPI Wait Interval */
+  uint8_t chalGnssEnvMinCpiWaitInterval_valid;  /**< Must be set to true if chalGnssEnvMinCpiWaitInterval is being passed */
+  uint32_t chalGnssEnvMinCpiWaitInterval;
+  /**<   Number of seconds that the Geofence engine is to wait between
+         CPI requests in challenging a GNSS environment.
+
+         Valid values: \n
+         - Positive values (in seconds)
+     */
+
+  /* Optional */
+  /*  Geofence Motion State Information */
+  uint8_t motionStateInfo_valid;  /**< Must be set to true if motionStateInfo is being passed */
+  uint32_t motionStateInfo_len;  /**< Must be set to # of elements in motionStateInfo */
+  qmiLocGeofenceMotionStateConfigStructT_v02 motionStateInfo[QMI_LOC_GEOFENCE_MAX_MOTION_STATES_V02];
+  /**<   \vspace{4pt} \n  Motion state informatino (e.g., motion state speed) that the
+         Geofence engine is to use.
+   */
+}qmiLocSetGeofenceEngineConfigReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to set the Geofence engine configuration. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Set Geofence Engine Configuration Status. */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Set Geofence Engine Configuration request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure  */
+
+  /* Optional */
+  /*  Transaction ID */
+  uint8_t transactionId_valid;  /**< Must be set to true if transactionId is being passed */
+  uint32_t transactionId;
+  /**<   Transaction ID that was specified in the Set Geofence Configuration
+       request. This parameter is always present if the status
+       field is set to SUCCESS. */
+}qmiLocSetGeofenceEngineConfigIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to get the Geofence engine configuration. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Transaction ID */
+  uint32_t transactionId;
+  /**<   Identifies the transaction. The transaction ID
+       is returned with the Get Geofence Engine Configuration
+       indication. */
+}qmiLocGetGeofenceEngineConfigReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to get the Geofence engine configuration. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Get Geofence Engine Configuration Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Get Geofence Engine Configuration request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure  */
+
+  /* Optional */
+  /*  Transaction ID */
+  uint8_t transactionId_valid;  /**< Must be set to true if transactionId is being passed */
+  uint32_t transactionId;
+  /**<   Transaction ID that was specified in the Get Geofence Engine Configuration
+       request. This parameter is always present
+       if the status field is set to SUCCESS. */
+
+  /* Optional */
+  /*  GPS Unavailable Indication Timeout */
+  uint8_t gnssUnavailableIndicationTimeout_valid;  /**< Must be set to true if gnssUnavailableIndicationTimeout is being passed */
+  uint32_t gnssUnavailableIndicationTimeout;
+  /**<   In a bad GNSS environment, the timeout after which the Geofence engine
+       sends out a GNSS unavailable indication. */
+
+  /* Optional */
+  /*  Max Geofences */
+  uint8_t maxGeofences_valid;  /**< Must be set to true if maxGeofences is being passed */
+  uint32_t maxGeofences;
+  /**<   Identifies the maximum number of Geofences that are currently supported
+       in the Geofence engine.  */
+
+  /* Optional */
+  /*  Enabled Motion Detection Sources */
+  uint8_t enabledMotionDetectionSources_valid;  /**< Must be set to true if enabledMotionDetectionSources is being passed */
+  qmiLocMotionDetectionSourceMaskT_v02 enabledMotionDetectionSources;
+  /**<   Identifies the sources that are currently enabled for motion detection
+ by the Geofence engine.
+
+ Valid values: \n
+      - QMI_LOC_MOTION_DETECTION_SOURCE_SENSORS (0x00000001) --  Sensors are used for motion detection
+      - QMI_LOC_MOTION_DETECTION_SOURCE_WIFI (0x00000002) --  Wi-Fi is used for motion detection
+      - QMI_LOC_MOTION_DETECTION_SOURCE_WWAN (0x00000004) --  Wireless WAN is used for motion detection  */
+
+  /* Optional */
+  /*  Enabled for CPI Position Injection Usage */
+  uint8_t enabledCpiUsage_valid;  /**< Must be set to true if enabledCpiUsage is being passed */
+  uint8_t enabledCpiUsage;
+  /**<   Indicates whether CPI usage is enabled.
+       \begin{itemize1}
+       \item    0x01 (TRUE)  -- CPI usage is enabled
+       \item    0x00 (FALSE) -- CPI usage is disabled
+       \vspace{-0.18in} \end{itemize1}*/
+}qmiLocGetGeofenceEngineConfigIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to edit a Geofence. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Geofence ID */
+  uint32_t geofenceId;
+  /**<   Identifier for the Geofence to be edited. */
+
+  /* Mandatory */
+  /*  Transaction ID */
+  uint32_t transactionId;
+  /**<   Transaction ID that was specified in the Edit Geofence
+       request. This parameter will always be present if the
+       status field is set to SUCCESS.
+ */
+
+  /* Optional */
+  /*  Geofence State */
+  uint8_t geofenceState_valid;  /**< Must be set to true if geofenceState is being passed */
+  qmiLocGeofenceStateEnumT_v02 geofenceState;
+  /**<   Specifies whether the Geofence is to be actively monitored.
+
+ Valid values: \n
+      - eQMI_LOC_GEOFENCE_STATE_ACTIVE (1) --  Geofence is being actively monitored
+      - eQMI_LOC_GEOFENCE_STATE_SUSPEND (2) --  Geofence monitoring is suspended
+ */
+
+  /* Optional */
+  /*  Breach Event Mask */
+  uint8_t breachMask_valid;  /**< Must be set to true if breachMask is being passed */
+  qmiLocGeofenceBreachMaskT_v02 breachMask;
+  /**<   Specifies the breach events in which the client is interested.
+
+       Valid values: \begin{itemize1}
+       \item    0x01 -- GEOFENCE_BREACH_ ENTERING_MASK
+       \item    0x02 -- GEOFENCE_BREACH_ LEAVING_MASK
+       \vspace{-0.18in} \end{itemize1} */
+
+  /* Optional */
+  /*  Responsiveness */
+  uint8_t responsiveness_valid;  /**< Must be set to true if responsiveness is being passed */
+  qmiLocGeofenceResponsivenessEnumT_v02 responsiveness;
+  /**<   Specifies the rate of detection for a Geofence breach.
+ This may impact the time lag between the actual breach event and
+ when it is reported. This parameter has power implications
+ and is to be fine-tuned to optimize power savings.
+
+ Valid values: \n
+      - eQMI_LOC_GEOFENCE_RESPONSIVENESS_LOW (0x01) --  The Geofence is monitored for a breach at a
+       low rate of 15 minutes. The gap between the actual breach and
+       the time it is reported is higher. This
+       setting results in lower power usage.
+      - eQMI_LOC_GEOFENCE_RESPONSIVENESS_MED (0x02) --  The Geofence is monitored for a breach at a
+       medium rate of 2 minutes. This is the default setting.
+      - eQMI_LOC_GEOFENCE_RESPONSIVENESS_HIGH (0x03) --  The Geofence is monitored for a breach at a
+       high rate of 10 seconds. The gap between the actual breach and
+       the time it is reported is low. This results
+       in higher power usage.
+      - eQMI_LOC_GEOFENCE_RESPONSIVENESS_ULTRA_HIGH (0x04) --  The Geofence is monitored for a breach at a
+       very high rate of 1 second. The gap between the actual breach and
+       the time it is reported is very low. This results
+       in very high power usage. This setting must be avoided whenever
+       possible because of the drastic power implications.
+      - eQMI_LOC_GEOFENCE_RESPONSIVENESS_CUSTOM (0x05) --  The Geofence is monitored for a breach at a
+       user defined rate. The gap between the actual breach and
+       the time it is reported depends on the user setting. The power implication
+       is inversely proportional to the responsiveness value set by the user.
+       The higher the responsiveness value, the lower the power implications, and vice-versa.
+ */
+}qmiLocEditGeofenceReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+typedef uint32_t qmiLocGeofenceConfigParamMaskT_v02;
+#define QMI_LOC_GEOFENCE_PARAM_MASK_GEOFENCE_STATE_V02 ((qmiLocGeofenceConfigParamMaskT_v02)0x00000001) /**<  Mask for the Geofence state parameter.  */
+#define QMI_LOC_GEOFENCE_PARAM_MASK_BREACH_MASK_V02 ((qmiLocGeofenceConfigParamMaskT_v02)0x00000002) /**<  Mask for Geofence breach mask parameter.  */
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to edit a Geofence. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Edit Geofence Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Edit Geofence request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure  */
+
+  /* Optional */
+  /*  Geofence ID */
+  uint8_t geofenceId_valid;  /**< Must be set to true if geofenceId is being passed */
+  uint32_t geofenceId;
+  /**<   Identifier for the Geofence that was edited. */
+
+  /* Optional */
+  /*  Transaction ID */
+  uint8_t transactionId_valid;  /**< Must be set to true if transactionId is being passed */
+  uint32_t transactionId;
+  /**<   Identifies the transaction. The transaction ID
+       is specified in the Edit Geofence request. */
+
+  /* Optional */
+  /*  Failed Parameters */
+  uint8_t failedParams_valid;  /**< Must be set to true if failedParams is being passed */
+  qmiLocGeofenceConfigParamMaskT_v02 failedParams;
+  /**<   Specified only when the status is not set to SUCCESS. If
+       the mask corresponding to a field is set, it indicates that
+       the Geofence parameter could not be edited.
+
+       Valid values: \begin{itemize1}
+       \item    0x00000001 -- GEOFENCE_PARAM_ MASK_GEOFENCE_STATE
+       \item    0x00000002 -- GEOFENCE_PARAM_ MASK_BREACH_MASK
+       \vspace{-0.18in} \end{itemize1} */
+}qmiLocEditGeofenceIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Requests the control point to get time zone information. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Get Time Zone Info Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Get Time Zone Info request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure  */
+}qmiLocEventGetTimeZoneReqIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint64_t dstOffset;
+  /**<   Offset for Daylight Savings Time in seconds. This is zero if the time zone is not in Daylight Savings
+       Time during the specified UTC timestamp. */
+
+  uint64_t rawOffset;
+  /**<   Offset from UTC (in seconds) for the current location. This does not take daylight savings into account. */
+}qmiLocTimeZoneStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to inject time zone information. */
+typedef struct {
+
+  /* Mandatory */
+  /*  UTC Time */
+  uint64_t timeUtc;
+  /**<   UTC time since Jan. 1, 1970.\n
+       - Units: Milliseconds */
+
+  /* Mandatory */
+  /*  Time Zone Information */
+  qmiLocTimeZoneStructT_v02 timeZone;
+}qmiLocInjectTimeZoneInfoReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to inject time zone information. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Inject Time Zone Info Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the inject time zone information.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure  */
+}qmiLocInjectTimeZoneInfoIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to get the best available
+                    position estimate from the location engine. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Transaction ID */
+  uint32_t transactionId;
+  /**<   Identifies the transaction. The transaction ID
+       is returned in the Get Best Available Position indication. */
+}qmiLocGetBestAvailablePositionReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to get the best available
+                    position estimate from the location engine. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Get Best Available Position Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Get Best Available Position request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure  */
+
+  /* Optional */
+  /*  Transaction ID */
+  uint8_t transactionId_valid;  /**< Must be set to true if transactionId is being passed */
+  uint32_t transactionId;
+  /**<   Transaction ID that was specified in the Get Best
+       Available Position request. This parameter will
+       always be present if the status field is set to
+       SUCCESS. */
+
+  /* Optional */
+  /*  Latitude */
+  uint8_t latitude_valid;  /**< Must be set to true if latitude is being passed */
+  double latitude;
+  /**<   Latitude (specified in WGS84 datum).
+       \begin{itemize1}
+       \item    Type: Floating point
+       \item    Units: Degrees
+       \item     Range: -90.0 to 90.0      \begin{itemize1}
+         \item    Positive values indicate northern latitude
+         \item    Negative values indicate southern latitude
+       \vspace{-0.18in} \end{itemize1} \end{itemize1} */
+
+  /* Optional */
+  /*   Longitude */
+  uint8_t longitude_valid;  /**< Must be set to true if longitude is being passed */
+  double longitude;
+  /**<   Longitude (specified in WGS84 datum).
+       \begin{itemize1}
+       \item    Type: Floating point
+       \item    Units: Degrees
+       \item    Range: -180.0 to 180.0     \begin{itemize1}
+         \item    Positive values indicate eastern longitude
+         \item    Negative values indicate western longitude
+       \vspace{-0.18in} \end{itemize1} \end{itemize1} */
+
+  /* Optional */
+  /*   Circular Horizontal Position Uncertainty */
+  uint8_t horUncCircular_valid;  /**< Must be set to true if horUncCircular is being passed */
+  float horUncCircular;
+  /**<   Horizontal position uncertainty (circular).\n
+       - Units: Meters */
+
+  /* Optional */
+  /*  Altitude With Respect to Ellipsoid */
+  uint8_t altitudeWrtEllipsoid_valid;  /**< Must be set to true if altitudeWrtEllipsoid is being passed */
+  float altitudeWrtEllipsoid;
+  /**<   Altitude with respect to the WGS84 ellipsoid.\n
+       - Units: Meters \n
+       - Range: -500 to 15883 */
+
+  /* Optional */
+  /*  Vertical Uncertainty */
+  uint8_t vertUnc_valid;  /**< Must be set to true if vertUnc is being passed */
+  float vertUnc;
+  /**<   Vertical uncertainty.\n
+       - Units: Meters */
+
+  /* Optional */
+  /*  UTC Timestamp */
+  uint8_t timestampUtc_valid;  /**< Must be set to true if timestampUtc is being passed */
+  uint64_t timestampUtc;
+  /**<   UTC timestamp.
+       \begin{itemize1}
+       \item Units: Milliseconds since Jan. 1, 1970
+       \vspace{-0.18in} \end{itemize1} */
+
+  /* Optional */
+  /*  Time Uncertainty */
+  uint8_t timeUnc_valid;  /**< Must be set to true if timeUnc is being passed */
+  float timeUnc;
+  /**<   Time uncertainty. \n
+       - Units: Milliseconds */
+
+  /* Optional */
+  /*  Horizontal Elliptical Uncertainty Semi-Minor Axis */
+  uint8_t horUncEllipseSemiMinor_valid;  /**< Must be set to true if horUncEllipseSemiMinor is being passed */
+  float horUncEllipseSemiMinor;
+  /**<   Semi-minor axis of horizontal elliptical uncertainty. \n
+       - Units: Meters */
+
+  /* Optional */
+  /*  Horizontal Elliptical Uncertainty Semi-Major Axis */
+  uint8_t horUncEllipseSemiMajor_valid;  /**< Must be set to true if horUncEllipseSemiMajor is being passed */
+  float horUncEllipseSemiMajor;
+  /**<   Semi-major axis of horizontal elliptical uncertainty. \n
+       - Units: Meters */
+
+  /* Optional */
+  /*  Horizontal Elliptical Uncertainty Azimuth */
+  uint8_t horUncEllipseOrientAzimuth_valid;  /**< Must be set to true if horUncEllipseOrientAzimuth is being passed */
+  float horUncEllipseOrientAzimuth;
+  /**<   Elliptical horizontal uncertainty azimuth of orientation. \n
+       - Units: Decimal degrees \n
+       - Range: 0 to 180 */
+
+  /* Optional */
+  /*  Horizontal Circular Confidence */
+  uint8_t horCircularConfidence_valid;  /**< Must be set to true if horCircularConfidence is being passed */
+  uint8_t horCircularConfidence;
+  /**<   Horizontal circular uncertainty confidence. \n
+       - Units: Percent \n
+       - Range: 0 to 99 */
+
+  /* Optional */
+  /*  Horizontal Elliptical Confidence */
+  uint8_t horEllipticalConfidence_valid;  /**< Must be set to true if horEllipticalConfidence is being passed */
+  uint8_t horEllipticalConfidence;
+  /**<   Horizontal elliptical uncertainty confidence. \n
+       - Units: Percent \n
+       - Range: 0 to 99 */
+
+  /* Optional */
+  /*  Horizontal Reliability */
+  uint8_t horReliability_valid;  /**< Must be set to true if horReliability is being passed */
+  qmiLocReliabilityEnumT_v02 horReliability;
+  /**<   Specifies the reliability of the horizontal position.
+
+ Valid values: \n
+      - eQMI_LOC_RELIABILITY_NOT_SET (0) --  Location reliability is not set
+      - eQMI_LOC_RELIABILITY_VERY_LOW (1) --  Location reliability is very low; use it at your own risk
+      - eQMI_LOC_RELIABILITY_LOW (2) --  Location reliability is low; little or no cross-checking is possible
+      - eQMI_LOC_RELIABILITY_MEDIUM (3) --  Location reliability is medium; limited cross-check passed
+      - eQMI_LOC_RELIABILITY_HIGH (4) --  Location reliability is high; strong cross-check passed
+ */
+
+  /* Optional */
+  /*  Horizontal Speed */
+  uint8_t horSpeed_valid;  /**< Must be set to true if horSpeed is being passed */
+  float horSpeed;
+  /**<   Horizontal speed. \n
+       - Units: Meters/second */
+
+  /* Optional */
+  /*  Horizontal Speed Uncertainty */
+  uint8_t horSpeedUnc_valid;  /**< Must be set to true if horSpeedUnc is being passed */
+  float horSpeedUnc;
+  /**<   Horizontal speed uncertainty. \n
+       - Units: Meters/second */
+
+  /* Optional */
+  /*  Altitude With Respect to Sea Level */
+  uint8_t altitudeWrtMeanSeaLevel_valid;  /**< Must be set to true if altitudeWrtMeanSeaLevel is being passed */
+  float altitudeWrtMeanSeaLevel;
+  /**<   Altitude with respect to mean sea level. \n
+       - Units: Meters */
+
+  /* Optional */
+  /*  Vertical Confidence */
+  uint8_t vertConfidence_valid;  /**< Must be set to true if vertConfidence is being passed */
+  uint8_t vertConfidence;
+  /**<   Vertical uncertainty confidence. \n
+       - Units: Percent \n
+       - Range: 0 to 99 */
+
+  /* Optional */
+  /*  Vertical Reliability */
+  uint8_t vertReliability_valid;  /**< Must be set to true if vertReliability is being passed */
+  qmiLocReliabilityEnumT_v02 vertReliability;
+  /**<   Specifies the reliability of the vertical position.
+
+ Valid values: \n
+      - eQMI_LOC_RELIABILITY_NOT_SET (0) --  Location reliability is not set
+      - eQMI_LOC_RELIABILITY_VERY_LOW (1) --  Location reliability is very low; use it at your own risk
+      - eQMI_LOC_RELIABILITY_LOW (2) --  Location reliability is low; little or no cross-checking is possible
+      - eQMI_LOC_RELIABILITY_MEDIUM (3) --  Location reliability is medium; limited cross-check passed
+      - eQMI_LOC_RELIABILITY_HIGH (4) --  Location reliability is high; strong cross-check passed
+ */
+
+  /* Optional */
+  /*  Vertical Speed */
+  uint8_t vertSpeed_valid;  /**< Must be set to true if vertSpeed is being passed */
+  float vertSpeed;
+  /**<   Vertical speed. \n
+         - Units: Meters/second */
+
+  /* Optional */
+  /*  Vertical Speed Uncertainty */
+  uint8_t vertSpeedUnc_valid;  /**< Must be set to true if vertSpeedUnc is being passed */
+  float vertSpeedUnc;
+  /**<   Vertical speed uncertainty. \n
+       - Units: Meters/second */
+
+  /* Optional */
+  /*  Heading */
+  uint8_t heading_valid;  /**< Must be set to true if heading is being passed */
+  float heading;
+  /**<   Heading. \n
+         - Units: Degrees \n
+         - Range: 0 to 359.999  */
+
+  /* Optional */
+  /*  Heading Uncertainty */
+  uint8_t headingUnc_valid;  /**< Must be set to true if headingUnc is being passed */
+  float headingUnc;
+  /**<   Heading uncertainty. \n
+       - Type: Floating point \n
+       - Range: 0 to 359.999 */
+
+  /* Optional */
+  /*  Magnetic Deviation */
+  uint8_t magneticDeviation_valid;  /**< Must be set to true if magneticDeviation is being passed */
+  float magneticDeviation;
+  /**<   Difference between the bearing to true north and the bearing shown
+      on a magnetic compass. The deviation is positive when the magnetic
+      north is east of true north. */
+
+  /* Optional */
+  /*  Technology Used Mask */
+  uint8_t technologyMask_valid;  /**< Must be set to true if technologyMask is being passed */
+  qmiLocPosTechMaskT_v02 technologyMask;
+  /**<   Technology used in computing this fix.
+ Valid bitmasks: \n
+      - QMI_LOC_POS_TECH_MASK_SATELLITE (0x00000001) --  Satellites were used to generate the fix
+      - QMI_LOC_POS_TECH_MASK_CELLID (0x00000002) --  Cell towers were used to generate the fix
+      - QMI_LOC_POS_TECH_MASK_WIFI (0x00000004) --  Wi-Fi access points were used to generate the fix
+      - QMI_LOC_POS_TECH_MASK_SENSORS (0x00000008) --  Sensors were used to generate the fix
+      - QMI_LOC_POS_TECH_MASK_REFERENCE_LOCATION (0x00000010) --  Reference Location was used to generate the fix
+      - QMI_LOC_POS_TECH_MASK_INJECTED_COARSE_POSITION (0x00000020) --  Coarse position injected into the location engine was used to
+        generate the fix
+      - QMI_LOC_POS_TECH_MASK_AFLT (0x00000040) --  AFLT was used to generate the fix
+      - QMI_LOC_POS_TECH_MASK_HYBRID (0x00000080) --  GNSS and network-provided measurements were used to
+        generate the fix
+ */
+
+  /* Optional */
+  /*  Dilution of Precision */
+  uint8_t DOP_valid;  /**< Must be set to true if DOP is being passed */
+  qmiLocDOPStructT_v02 DOP;
+
+  /* Optional */
+  /*  GPS Time */
+  uint8_t gpsTime_valid;  /**< Must be set to true if gpsTime is being passed */
+  qmiLocGPSTimeStructT_v02 gpsTime;
+
+  /* Optional */
+  /*  Time Source */
+  uint8_t timeSrc_valid;  /**< Must be set to true if timeSrc is being passed */
+  qmiLocTimeSourceEnumT_v02 timeSrc;
+  /**<   Time source.
+ Valid values: \n
+      - eQMI_LOC_TIME_SRC_INVALID (0) --  Invalid time.
+      - eQMI_LOC_TIME_SRC_NETWORK_TIME_TRANSFER (1) --  Time is set by the 1X system
+      - eQMI_LOC_TIME_SRC_NETWORK_TIME_TAGGING (2) --  Time is set by WCDMA/GSM time tagging (that is,
+       associating network time with GPS time)
+      - eQMI_LOC_TIME_SRC_EXTERNAL_INPUT (3) --  Time is set by an external injection
+      - eQMI_LOC_TIME_SRC_TOW_DECODE (4) --  Time is set after decoding over-the-air GPS navigation data
+       from one GPS satellite
+      - eQMI_LOC_TIME_SRC_TOW_CONFIRMED (5) --  Time is set after decoding over-the-air GPS navigation data
+       from multiple satellites
+      - eQMI_LOC_TIME_SRC_TOW_AND_WEEK_CONFIRMED (6) --  Both time of the week and the GPS week number are known
+      - eQMI_LOC_TIME_SRC_NAV_SOLUTION (7) --  Time is set by the position engine after the fix is obtained
+      - eQMI_LOC_TIME_SRC_SOLVE_FOR_TIME (8) --  Time is set by the position engine after performing SFT;
+       this is done when the clock time uncertainty is large
+      - eQMI_LOC_TIME_SRC_GLO_TOW_DECODE (9) --  Time is set after decoding GLO satellites
+      - eQMI_LOC_TIME_SRC_TIME_TRANSFORM (10) --  Time is set after transforming the GPS to GLO time
+      - eQMI_LOC_TIME_SRC_WCDMA_SLEEP_TIME_TAGGING (11) --  Time is set by the sleep time tag provided by the WCDMA network
+      - eQMI_LOC_TIME_SRC_GSM_SLEEP_TIME_TAGGING (12) --  Time is set by the sleep time tag provided by the GSM network
+      - eQMI_LOC_TIME_SRC_UNKNOWN (13) --  Source of the time is unknown
+      - eQMI_LOC_TIME_SRC_SYSTEM_TIMETICK (14) --  Time is derived from the system clock (better known as the slow clock);
+       GNSS time is maintained irrespective of the GNSS receiver state
+      - eQMI_LOC_TIME_SRC_QZSS_TOW_DECODE (15) --  Time is set after decoding QZSS satellites
+      - eQMI_LOC_TIME_SRC_BDS_TOW_DECODE (16) --  Time is set after decoding BDS satellites
+      - eQMI_LOC_TIME_SRC_GAL_TOW_DECODE (17) --  Time is set after decoding GAL satellites
+ */
+
+  /* Optional */
+  /*  Sensor Data Usage */
+  uint8_t sensorDataUsage_valid;  /**< Must be set to true if sensorDataUsage is being passed */
+  qmiLocSensorUsageIndicatorStructT_v02 sensorDataUsage;
+
+  /* Optional */
+  /*  SVs Used to Calculate the Fix */
+  uint8_t gnssSvUsedList_valid;  /**< Must be set to true if gnssSvUsedList is being passed */
+  uint32_t gnssSvUsedList_len;  /**< Must be set to # of elements in gnssSvUsedList */
+  uint16_t gnssSvUsedList[QMI_LOC_MAX_SV_USED_LIST_LENGTH_V02];
+  /**<   Each entry in the list contains the SV ID of a satellite
+       used for calculating this position report. The following
+       information is associated with each SV ID: \n
+       Range: \n
+       - For GPS:     1 to 32 \n
+       - For GLONASS: 65 to 96 \n
+       - For SBAS:    120 to 158 and 183 to 187 \n
+       - For QZSS:    193 to 197 \n
+       - For BDS:     201 to 237 \n
+       - For GAL:     301 to 336
+       */
+}qmiLocGetBestAvailablePositionIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCMOTIONSTATEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_MOTION_STATE_UNKNOWN_V02 = 0, /**<  Device state is not known  */
+  eQMI_LOC_MOTION_STATE_STATIONARY_V02 = 1, /**<  Device state is Stationary  */
+  eQMI_LOC_MOTION_STATE_IN_MOTION_V02 = 2, /**<  Device state is In Motion  */
+  QMILOCMOTIONSTATEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocMotionStateEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCMOTIONMODEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_MOTION_MODE_UNKNOWN_V02 = 0, /**<  Device movement is not known  */
+  eQMI_LOC_MOTION_MODE_STATIONARY_V02 = 1, /**<  Device is not moving  */
+  eQMI_LOC_MOTION_MODE_PEDESTRIAN_UNKNOWN_V02 = 200, /**<  Device movement is in Pedestrian mode; nothing else is known about the movement  */
+  eQMI_LOC_MOTION_MODE_PEDESTRIAN_WALKING_V02 = 201, /**<  Device movement is in pedestrian Walking mode  */
+  eQMI_LOC_MOTION_MODE_PEDESTRIAN_RUNNING_V02 = 202, /**<  Device movement is in pedestrian Running mode  */
+  eQMI_LOC_MOTION_MODE_VEHICLE_UNKNOWN_V02 = 300, /**<  Device movement is in Vehicular mode; nothing else is known about the movement  */
+  QMILOCMOTIONMODEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocMotionModeEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  qmiLocMotionStateEnumT_v02 motion_state;
+  /**<   Current motion state of the user.
+
+ Valid values: \n
+      - eQMI_LOC_MOTION_STATE_UNKNOWN (0) --  Device state is not known
+      - eQMI_LOC_MOTION_STATE_STATIONARY (1) --  Device state is Stationary
+      - eQMI_LOC_MOTION_STATE_IN_MOTION (2) --  Device state is In Motion
+ */
+
+  qmiLocMotionModeEnumT_v02 motion_mode;
+  /**<   Modes of user motion.
+
+ Valid values: \n
+      - eQMI_LOC_MOTION_MODE_UNKNOWN (0) --  Device movement is not known
+      - eQMI_LOC_MOTION_MODE_STATIONARY (1) --  Device is not moving
+      - eQMI_LOC_MOTION_MODE_PEDESTRIAN_UNKNOWN (200) --  Device movement is in Pedestrian mode; nothing else is known about the movement
+      - eQMI_LOC_MOTION_MODE_PEDESTRIAN_WALKING (201) --  Device movement is in pedestrian Walking mode
+      - eQMI_LOC_MOTION_MODE_PEDESTRIAN_RUNNING (202) --  Device movement is in pedestrian Running mode
+      - eQMI_LOC_MOTION_MODE_VEHICLE_UNKNOWN (300) --  Device movement is in Vehicular mode; nothing else is known about the movement
+ */
+
+  float probability_of_state;
+  /**<   Probability that the device is actually undergoing the motion state
+       specified by the combination of the values of motion_state, motion_mode,
+       and motion_sub_mode. \vspace{0.1in}
+
+       This value is a floating point number in the range of 0 to 100, in
+       units of percent probability. Any value greater than 99.9999 is
+       applied as 99.9999. \vspace{0.1in}
+
+       It is recommended that if a particular combination of motion_state and
+       motion_mode cannot be determined with more than 50 percent confidence,
+       that a more general statement of user motion be made.
+       For example, if the mode of In-Motion + Pedestrian-Running can only be
+       determined with 50 percent probability, and the simpler statement of In-Motion
+       can be determined with 90 percent probability, it is recommended that this field
+       be used to simply state In-Motion with 90 percent probability. \vspace{0.1in}
+
+       If the motion_state is not known, the value in this field is not used.
+  */
+
+  uint16_t age;
+  /**<   Age of the motion data in milliseconds at the time of injection.
+  */
+
+  uint16_t timeout;
+  /**<   If the age of the motion data input exceeds the timeout value, the data
+       will no longer be used. The timeout value is in units of milliseconds.
+       Values in the range of 0 to 10000 are accepted. If 65535 is provided,
+       the motion data input is applied until the next input is
+       received. \n
+
+       If the determination of motion data is an instantaneous observation
+       and no notice is guaranteed to be given via the QMI on a change in the
+       state of the motion data, it is recommended that this field be set to 0. \vspace{0.1in}
+
+       If the determination of motion data is continuously monitored
+       external to the QMI and an update is always applied to the QMI upon any
+       change in state, a value of 65535 is used for this field.
+       Note that in this case, if a certain mode is set and is not later
+       unset (e.g., by sending in the request message with a user motion
+       state of Unknown), the value is applied indefinitely.
+  */
+}qmiLocMotionDataStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Injects motion data for MSM GPS service use. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Motion Data */
+  qmiLocMotionDataStructT_v02 motion_data;
+}qmiLocInjectMotionDataReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Injects motion data for MSM GPS service use. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Inject Motion Data Request Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Inject Motion Data request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+}qmiLocInjectMotionDataIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to retrieve the list of network
+                    initiated Geofence IDs. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Transaction ID */
+  uint32_t transactionId;
+  /**<   Identifies the transaction. The same transaction ID
+       will be returned in the Get NI Geofence ID List indication. */
+}qmiLocGetNiGeofenceIdListReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to retrieve the list of network
+                    initiated Geofence IDs. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Get NI Geofence ID List Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Get NI Geofence ID List request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure  */
+
+  /* Optional */
+  /*  Transaction ID */
+  uint8_t transactionId_valid;  /**< Must be set to true if transactionId is being passed */
+  uint32_t transactionId;
+  /**<   Transaction ID that was specified in the Get NI
+       Geofence ID List request. */
+
+  /* Optional */
+  /*  NI Geofence ID List */
+  uint8_t niGeofenceIdList_valid;  /**< Must be set to true if niGeofenceIdList is being passed */
+  uint32_t niGeofenceIdList_len;  /**< Must be set to # of elements in niGeofenceIdList */
+  uint32_t niGeofenceIdList[QMI_LOC_MAX_NI_GEOFENCE_ID_LIST_LENGTH_V02];
+  /**<   List containing the NI Geofence IDs.
+       - Type: Array of unsigned 32-bit integers \n
+       - Maximum NI Geofence ID List length: 16 */
+}qmiLocGetNiGeofenceIdListIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint32_t MCC;
+  /**<   GSM mobile country code. Refer to ITU-T E.212 \hyperref[ITU-T E.212]{ITU-T E.212}. */
+
+  uint32_t MNC;
+  /**<   GSM mobile network code. Refer to \hyperref[ITU-T E.212]{ITU-T E.212}. */
+
+  uint32_t LAC;
+  /**<   GSM location area code. Refer to \hyperref[ITU-T E.212]{ITU-T E.212}. */
+
+  uint32_t CID;
+  /**<   GSM cell identification. Refer to \hyperref[ITU-T E.212]{ITU-T E.212}. */
+}qmiLocGSMCellIdStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Injects GSM cell information into the location
+                    engine. */
+typedef struct {
+
+  /* Mandatory */
+  /*  GSM Cell ID */
+  qmiLocGSMCellIdStructT_v02 gsmCellId;
+  /**<   \vspace{0.06in} \n Identifies the GSM cell on which the device is currently camped. */
+
+  /* Mandatory */
+  /*  Roaming Status */
+  uint8_t roamingStatus;
+  /**<   Indicates whether the device is roaming.
+       \begin{itemize1}
+       \item    0x01 (TRUE)  -- Device is roaming
+       \item    0x00 (FALSE) -- Device is not roaming
+       \vspace{-0.18in} \end{itemize1}*/
+
+  /* Optional */
+  /*  Timing Advance */
+  uint8_t timingAdvance_valid;  /**< Must be set to true if timingAdvance is being passed */
+  uint32_t timingAdvance;
+  /**<   Round trip delay between the MS and the BS, in units of 3.69 microseconds.
+       Refer to 3GPP \hyperref[TS 05.10]{TS 05.10} and \hyperref[TS 45.010]{TS 45.010}. */
+}qmiLocInjectGSMCellInfoReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Injects GSM cell information into the location
+                    engine. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Inject GSM Cell Info Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Inject GSM Cell Info request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure  */
+}qmiLocInjectGSMCellInfoIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCROAMINGSTATUSENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_PHONE_NOT_ROAMING_V02 = 1, /**<  Modem is camped on a home network  */
+  eQMI_LOC_PHONE_ROAMING_V02 = 2, /**<  Modem is camped on a roaming network  */
+  QMILOCROAMINGSTATUSENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocRoamingStatusEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint32_t mcc;
+  /**<   WCDMA mobile country code. Refer to \hyperref[ITU-T E.212]{ITU-T E.212}. */
+
+  uint32_t mnc;
+  /**<   WCDMA mobile network code. Refer to \hyperref[ITU-T E.212]{ITU-T E.212}. */
+
+  uint32_t cid;
+  /**<   WCDMA cell identity. Refer to \hyperref[ITU-T E.212]{ITU-T E.212}. */
+}qmiLocWCDMACellIdStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Injects WCDMA cell information into the location
+                    engine. */
+typedef struct {
+
+  /* Mandatory */
+  /*  WCDMA Cell ID */
+  qmiLocWCDMACellIdStructT_v02 wcdmaCellId;
+  /**<   \n Identifies the WCDMA cell on which the device is currently camped. */
+
+  /* Mandatory */
+  /*  Roaming Status */
+  qmiLocRoamingStatusEnumT_v02 roamingStatus;
+  /**<   Indicates whether the device is roaming.
+
+ Valid values: \n
+      - eQMI_LOC_PHONE_NOT_ROAMING (1) --  Modem is camped on a home network
+      - eQMI_LOC_PHONE_ROAMING (2) --  Modem is camped on a roaming network
+ */
+
+  /* Optional */
+  /*  Cell Frequency */
+  uint8_t freq_valid;  /**< Must be set to true if freq is being passed */
+  uint32_t freq;
+  /**<   Frequency information of the serving cell. \n
+       Valid range: 0 to 16383 \n
+       Refer to 3GPP \hyperref[TS 25.331]{TS 25.331}. */
+
+  /* Optional */
+  /*  Primary Scrambling Code */
+  uint8_t psc_valid;  /**< Must be set to true if psc is being passed */
+  uint32_t psc;
+  /**<   Primary scrambling code of the serving cell. \n
+       Valid range: 0 to 511 \n
+       Refer to 3GPP \hyperref[TS 25.331]{TS 25.331}. */
+}qmiLocInjectWCDMACellInfoReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Injects WCDMA cell information into the location
+                    engine. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Inject WCDMA Cell Info Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Inject WCDMA Cell Info request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure  */
+}qmiLocInjectWCDMACellInfoIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint32_t mcc;
+  /**<   TDSCDMA mobile country code. Refer to \hyperref[ITU-T E.212]{ITU-T E.212}. */
+
+  uint32_t mnc;
+  /**<   TDSCDMA mobile network code. Refer to \hyperref[ITU-T E.212]{ITU-T E.212}. */
+
+  uint32_t cid;
+  /**<   TDSCDMA cell identity. Refer to 3GPP \hyperref[TS 25.331]{TS 25.331}. */
+
+  uint32_t lac;
+  /**<   TDSCDMA location area code. Refer to \hyperref[ITU-T E.212]{ITU-T E.212}. */
+}qmiLocTDSCDMACellIdStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Injects TDSCDMA cell information into the location
+                    engine. */
+typedef struct {
+
+  /* Mandatory */
+  /*  TDSCDMA Cell ID */
+  qmiLocTDSCDMACellIdStructT_v02 tdscdmaCellId;
+  /**<   \n Identifies the TDSCDMA cell on which the device is currently camped. */
+
+  /* Mandatory */
+  /*  Roaming Status */
+  qmiLocRoamingStatusEnumT_v02 roamingStatus;
+  /**<   Indicates whether the device is roaming.
+
+ Valid values: \n
+      - eQMI_LOC_PHONE_NOT_ROAMING (1) --  Modem is camped on a home network
+      - eQMI_LOC_PHONE_ROAMING (2) --  Modem is camped on a roaming network
+ */
+
+  /* Optional */
+  /*  Cell Frequency */
+  uint8_t freq_valid;  /**< Must be set to true if freq is being passed */
+  uint32_t freq;
+  /**<   Frequency information of the serving cell. \n
+       Valid range: 0 to 16383 \n
+       Refer to 3GPP \hyperref[TS 25.331]{TS 25.331}. */
+}qmiLocInjectTDSCDMACellInfoReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Injects TDSCDMA cell information into the location
+                    engine. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Inject TDSCDMA Cell Info Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Inject TDSCDMA Cell Info request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure  */
+}qmiLocInjectTDSCDMACellInfoIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Injects the phone's subscriber ID into the location engine. */
+typedef struct {
+
+  /* Optional */
+  /*  Preferred IMSI */
+  uint8_t preferredIMSI_valid;  /**< Must be set to true if preferredIMSI is being passed */
+  uint64_t preferredIMSI;
+  /**<   IMSI number of the preferred RAT. Refer to \hyperref[ITU-T E.212]{ITU-T E.212}.*/
+
+  /* Optional */
+  /*  Preferred MSISDN */
+  uint8_t preferredMSISDN_valid;  /**< Must be set to true if preferredMSISDN is being passed */
+  uint64_t preferredMSISDN;
+  /**<   MSISDN number of the preferred RAT. Refer to \hyperref[ITU-T E.212]{ITU-T E.212}.*/
+}qmiLocInjectSubscriberIDReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Injects the phone's subscriber ID into the location engine. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Inject Subscriber ID Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Inject Subscriber ID request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure  */
+}qmiLocInjectSubscriberIDIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCINJECTEDNETWORKINITIATEDMESSAGETYPEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_INJECTED_NETWORK_INITIATED_MESSAGE_TYPE_SUPL_V02 = 0, /**<  SUPL network-initiated message is being injected.  */
+  QMILOCINJECTEDNETWORKINITIATEDMESSAGETYPEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocInjectedNetworkInitiatedMessageTypeEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Injects a network-initiated message into the location
+                    engine. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Injected Network Initiated Message Type */
+  qmiLocInjectedNetworkInitiatedMessageTypeEnumT_v02 injectedNIMessageType;
+  /**<   Type of the network-initiated message being injected.
+
+ Valid values: \n
+      - eQMI_LOC_INJECTED_NETWORK_INITIATED_MESSAGE_TYPE_SUPL (0) --  SUPL network-initiated message is being injected.  */
+
+  /* Mandatory */
+  /*  Injected Network Initiated Message */
+  uint32_t injectedNIMessage_len;  /**< Must be set to # of elements in injectedNIMessage */
+  uint8_t injectedNIMessage[QMI_LOC_MAX_INJECTED_NETWORK_INITIATED_MESSAGE_LENGTH_V02];
+  /**<   Network-initiated message body.
+       If the inject NI message type is TYPE_SUPL, the message contains
+       a SUPL INIT message as defined in OMA-TS-ULP-V2_\hyperref[0-20110527-C]{0-20110527-C}. */
+}qmiLocInjectNetworkInitiatedMessageReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Injects a network-initiated message into the location
+                    engine. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Inject Network Initiated Message Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Inject Network Initiated Message request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure  */
+}qmiLocInjectNetworkInitiatedMessageIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Notifies the location engine that the device is out of
+                    service. */
+typedef struct {
+  /* This element is a placeholder to prevent the declaration of
+     an empty struct.  DO NOT USE THIS FIELD UNDER ANY CIRCUMSTANCE */
+  char __placeholder;
+}qmiLocWWANOutOfServiceNotificationReqMsgT_v02;
+
+  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Notifies the location engine that the device is out of
+                    service. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Notify WWAN Out of Service Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Notify WWAN Out of Service request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+}qmiLocWWANOutOfServiceNotificationIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to inject pedometer data
+                    into the location engine. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Time Source */
+  qmiLocSensorDataTimeSourceEnumT_v02 timeSource;
+  /**<   Time source for the pedometer. The location service uses
+ this field to identify the time reference used in the
+ pedometer data time stamp.
+
+ Valid values: \n
+      - eQMI_LOC_SENSOR_TIME_SOURCE_UNSPECIFIED (0) --  Sensor time source is unspecified
+      - eQMI_LOC_SENSOR_TIME_SOURCE_COMMON (1) --  Time source is common between the sensors and
+       the location engine
+ */
+
+  /* Mandatory */
+  /*  Pedometer Report Timestamp */
+  uint32_t timestamp;
+  /**<   Time stamp of the last step event in this report, that is, the time stamp
+       of the step event that caused this report to be generated.
+       The time stamp is in the time reference scale that is
+       used by the pedometer time source. \n
+       - Units: Milliseconds */
+
+  /* Mandatory */
+  /*  Time Interval */
+  uint32_t timeInterval;
+  /**<   Time interval during which the step count was calculated. Subtracting
+       timeInterval from the timestamp field yields the time when
+       the step detection for the first step in this report started. \n
+       - Units: Milliseconds */
+
+  /* Mandatory */
+  /*  Step Count */
+  uint32_t stepCount;
+  /**<   Number of steps counted during the time interval. */
+
+  /* Optional */
+  /*  Step Confidence */
+  uint8_t stepConfidence_valid;  /**< Must be set to true if stepConfidence is being passed */
+  uint8_t stepConfidence;
+  /**<   Confidence associated with the step. This field is only applicable
+       for a single step report, that is, if the step count is one. \n
+       - Range: 0 to 100 \n
+       \textbf{Note:} The report is ignored if confidence is 0. */
+
+  /* Optional */
+  /*  Step Count Uncertainty */
+  uint8_t stepCountUncertainty_valid;  /**< Must be set to true if stepCountUncertainty is being passed */
+  float stepCountUncertainty;
+  /**<   Uncertainty (in steps) associated with the step count. */
+
+  /* Optional */
+  /*  Step Rate */
+  uint8_t stepRate_valid;  /**< Must be set to true if stepRate is being passed */
+  float stepRate;
+  /**<   Current estimate for the rate of steps per second. \n
+       - Units: steps/second \n
+       - Range: >= 0.0 */
+}qmiLocPedometerReportReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to inject pedometer data
+                    into the location engine. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Status of Pedometer Report Request */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Pedometer Report request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+}qmiLocPedometerReportIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to get the batching size. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Transaction ID */
+  uint32_t transactionId;
+  /**<   Identifies the transaction. The transaction ID is returned in the Get
+       Batch Size indication. */
+
+  /* Mandatory */
+  /*  Requested Batch Size */
+  uint32_t batchSize;
+  /**<   Request the service with the number of location fixes to be batched. */
+}qmiLocGetBatchSizeReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to get the batching size. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Get Batch Size Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Get Batch Size request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Mandatory */
+  /*  Transaction ID */
+  uint32_t transactionId;
+  /**<   Transaction ID that was specified in the Get Batch
+       Size request.
+       */
+
+  /* Mandatory */
+  /*  Batch Size Supported */
+  uint32_t batchSize;
+  /**<   Number of location fixes that the service is able to batch.
+       The batch size value is returned as 0 in the case of a failure status.
+  */
+}qmiLocGetBatchSizeIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to initiate a batching session. */
+typedef struct {
+
+  /* Optional */
+  /*  Minimum Interval Between Position Reports */
+  uint8_t minInterval_valid;  /**< Must be set to true if minInterval is being passed */
+  uint32_t minInterval;
+  /**<   Minimum time interval, specified by the control point, that must elapse between
+       position reports. \n
+       - Units: milliseconds \n
+       - Default: 60000 ms
+  */
+
+  /* Optional */
+  /*  Horizontal Accuracy Level */
+  uint8_t horizontalAccuracyLevel_valid;  /**< Must be set to true if horizontalAccuracyLevel is being passed */
+  qmiLocAccuracyLevelEnumT_v02 horizontalAccuracyLevel;
+  /**<   Specifies the horizontal accuracy level required by the control point.
+ If not specified, accuracy defaults to LOW.
+
+ Valid values: \n
+      - eQMI_LOC_ACCURACY_LOW (1) --  Low accuracy
+      - eQMI_LOC_ACCURACY_MED (2) --  Medium accuracy
+      - eQMI_LOC_ACCURACY_HIGH (3) --  High accuracy
+ */
+
+  /* Optional */
+  /*  Fix Session Timeout Period */
+  uint8_t fixSessionTimeout_valid;  /**< Must be set to true if fixSessionTimeout is being passed */
+  uint32_t fixSessionTimeout;
+  /**<   Configures the fix session timeout duration. \n
+       - Units: Milliseconds \n
+       - Default: 20,000 ms
+  */
+
+  /* Optional */
+  /*  Minimum Distance */
+  uint8_t minDistance_valid;  /**< Must be set to true if minDistance is being passed */
+  uint32_t minDistance;
+  /**<   Specifies the minimum distance that should be traversed before a
+       position should be batched.
+       If no distance is specified, the positions are batched after
+       the minInterval period expires. If both minInterval and minDistance are
+       specified, the position are batched only after minInterval has
+       expired AND minDistance has been traversed. \n
+       - Units: Meters
+  */
+
+  /* Optional */
+  /*  Batch All Positions */
+  uint8_t batchAllPos_valid;  /**< Must be set to true if batchAllPos is being passed */
+  uint8_t batchAllPos;
+  /**<   Values: \n
+       - TRUE -- All positions that are available must be batched. For example,
+              if any other type of positioning is active (such as 1 Hz tracking), all
+              positions computed for that use case are also batched. This may
+              result in the BATCH_FULL indication getting generated earlier. \n
+       - FALSE -- Only positions that meet the time and/or distance criteria are batched
+                  (default).
+  */
+
+  /* Optional */
+  /*  Request ID */
+  uint8_t requestId_valid;  /**< Must be set to true if requestId is being passed */
+  uint32_t requestId;
+  /**<   Identifies the request. A batching client can start multiple batching
+       requests with different batching parameters,
+       however, positions corresponding to all requests from the same client are
+       batched in the same buffer. A request ID value of 0 is considered invalid. \n
+       Valid Values 0x01 - 0xFFFFFFFF
+  */
+}qmiLocStartBatchingReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to initiate a batching session. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Start Batching Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Start Batching request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Optional */
+  /*  Request ID */
+  uint8_t requestId_valid;  /**< Must be set to true if requestId is being passed */
+  uint32_t requestId;
+  /**<   Identifies the request. A batching client can start multiple batching
+       requests with different batching parameters, however, positions
+       corresponding to all requests from the same client are
+       batched in the same buffer. \n
+       Valid Values 0x01 - 0xFFFFFFFF
+  */
+}qmiLocStartBatchingIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used to notify the control point that the batched buffer is full. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Number of Entries in the Batch During Full Event */
+  uint32_t batchCount;
+  /**<   Number of entries in the batch during a full event.
+  */
+}qmiLocEventBatchFullIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+typedef uint64_t qmiLocBatchedReportValidFieldsMaskT_v02;
+#define QMI_LOC_BATCHED_REPORT_MASK_VALID_LATITUDE_V02 ((qmiLocBatchedReportValidFieldsMaskT_v02)0x00000001ull) /**<  Latitude field is valid for this fix  */
+#define QMI_LOC_BATCHED_REPORT_MASK_VALID_LONGITUDE_V02 ((qmiLocBatchedReportValidFieldsMaskT_v02)0x00000002ull) /**<  Longitude field is valid for this fix  */
+#define QMI_LOC_BATCHED_REPORT_MASK_VALID_HOR_CIR_UNC_V02 ((qmiLocBatchedReportValidFieldsMaskT_v02)0x00000004ull) /**<  Horizontal circular uncertainty field is valid for this fix  */
+#define QMI_LOC_BATCHED_REPORT_MASK_VALID_SPEED_HOR_V02 ((qmiLocBatchedReportValidFieldsMaskT_v02)0x00000008ull) /**<  Horizontal speed field is valid for this fix  */
+#define QMI_LOC_BATCHED_REPORT_MASK_VALID_SPEED_UNC_V02 ((qmiLocBatchedReportValidFieldsMaskT_v02)0x00000010ull) /**<  Speed uncertainty field is valid for this fix  */
+#define QMI_LOC_BATCHED_REPORT_MASK_VALID_ALT_WRT_ELP_V02 ((qmiLocBatchedReportValidFieldsMaskT_v02)0x00000020ull) /**<  Altitude with respect to ellipsoid field is valid for this fix  */
+#define QMI_LOC_BATCHED_REPORT_MASK_VALID_SPEED_VER_V02 ((qmiLocBatchedReportValidFieldsMaskT_v02)0x00000040ull) /**<  Vertical speed field is valid for this fix  */
+#define QMI_LOC_BATCHED_REPORT_MASK_VALID_HEADING_V02 ((qmiLocBatchedReportValidFieldsMaskT_v02)0x00000080ull) /**<  Heading field is valid for this fix  */
+#define QMI_LOC_BATCHED_REPORT_MASK_VALID_HEADING_UNC_V02 ((qmiLocBatchedReportValidFieldsMaskT_v02)0x00000100ull) /**<  Heading uncertainty field is valid for this fix  */
+#define QMI_LOC_BATCHED_REPORT_MASK_VALID_TECH_MASK_V02 ((qmiLocBatchedReportValidFieldsMaskT_v02)0x00000200ull) /**<  Technology source mask field is valid for this fix  */
+#define QMI_LOC_BATCHED_REPORT_MASK_VALID_TIMESTAMP_UTC_V02 ((qmiLocBatchedReportValidFieldsMaskT_v02)0x00000400ull) /**<  UTC timestamp field is valid for this fix  */
+#define QMI_LOC_BATCHED_REPORT_MASK_VALID_TIME_UNC_V02 ((qmiLocBatchedReportValidFieldsMaskT_v02)0x00000800ull) /**<  Time uncertainty field is valid for this fix  */
+#define QMI_LOC_BATCHED_REPORT_MASK_VALID_MAGNETIC_DEV_V02 ((qmiLocBatchedReportValidFieldsMaskT_v02)0x00001000ull) /**<  Magnetic deviation field is valid for this fix  */
+#define QMI_LOC_BATCHED_REPORT_MASK_VALID_VERT_UNC_V02 ((qmiLocBatchedReportValidFieldsMaskT_v02)0x00002000ull) /**<  Vertical uncertainty field is valid for this fix  */
+#define QMI_LOC_BATCHED_REPORT_MASK_VALID_HOR_CONF_V02 ((qmiLocBatchedReportValidFieldsMaskT_v02)0x00004000ull) /**<  Horizontal confidence field is valid for this fix  */
+#define QMI_LOC_BATCHED_REPORT_MASK_VALID_TIMESTAMP_GPS_V02 ((qmiLocBatchedReportValidFieldsMaskT_v02)0x00008000ull) /**<  GPS timestamp field is valid for this fix  */
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint32_t fixId;
+  /**<   Fix count for the session. The count starts at 0 and increments by one for
+  each successive batched position report for a particular session. */
+
+  qmiLocBatchedReportValidFieldsMaskT_v02 validFields;
+  /**<   Mask of all valid fields for this fix.
+ Valid bitmasks: \n
+      - QMI_LOC_BATCHED_REPORT_MASK_VALID_LATITUDE (0x00000001) --  Latitude field is valid for this fix
+      - QMI_LOC_BATCHED_REPORT_MASK_VALID_LONGITUDE (0x00000002) --  Longitude field is valid for this fix
+      - QMI_LOC_BATCHED_REPORT_MASK_VALID_HOR_CIR_UNC (0x00000004) --  Horizontal circular uncertainty field is valid for this fix
+      - QMI_LOC_BATCHED_REPORT_MASK_VALID_SPEED_HOR (0x00000008) --  Horizontal speed field is valid for this fix
+      - QMI_LOC_BATCHED_REPORT_MASK_VALID_SPEED_UNC (0x00000010) --  Speed uncertainty field is valid for this fix
+      - QMI_LOC_BATCHED_REPORT_MASK_VALID_ALT_WRT_ELP (0x00000020) --  Altitude with respect to ellipsoid field is valid for this fix
+      - QMI_LOC_BATCHED_REPORT_MASK_VALID_SPEED_VER (0x00000040) --  Vertical speed field is valid for this fix
+      - QMI_LOC_BATCHED_REPORT_MASK_VALID_HEADING (0x00000080) --  Heading field is valid for this fix
+      - QMI_LOC_BATCHED_REPORT_MASK_VALID_HEADING_UNC (0x00000100) --  Heading uncertainty field is valid for this fix
+      - QMI_LOC_BATCHED_REPORT_MASK_VALID_TECH_MASK (0x00000200) --  Technology source mask field is valid for this fix
+      - QMI_LOC_BATCHED_REPORT_MASK_VALID_TIMESTAMP_UTC (0x00000400) --  UTC timestamp field is valid for this fix
+      - QMI_LOC_BATCHED_REPORT_MASK_VALID_TIME_UNC (0x00000800) --  Time uncertainty field is valid for this fix
+      - QMI_LOC_BATCHED_REPORT_MASK_VALID_MAGNETIC_DEV (0x00001000) --  Magnetic deviation field is valid for this fix
+      - QMI_LOC_BATCHED_REPORT_MASK_VALID_VERT_UNC (0x00002000) --  Vertical uncertainty field is valid for this fix
+      - QMI_LOC_BATCHED_REPORT_MASK_VALID_HOR_CONF (0x00004000) --  Horizontal confidence field is valid for this fix
+      - QMI_LOC_BATCHED_REPORT_MASK_VALID_TIMESTAMP_GPS (0x00008000) --  GPS timestamp field is valid for this fix
+ */
+
+  double latitude;
+  /**<   Latitude (specified in WGS84 datum).
+       \begin{itemize1}
+       \item    Type: Floating point
+       \item    Units: Degrees
+       \item    Range: -90.0 to 90.0   \begin{itemize1}
+         \item    Positive values indicate northern latitude
+         \item    Negative values indicate southern latitude
+       \vspace{-0.18in} \end{itemize1} \end{itemize1} */
+
+  double longitude;
+  /**<   Longitude (specified in WGS84 datum).
+       \begin{itemize1}
+       \item    Type: Floating point
+       \item    Units: Degrees
+       \item    Range: -180.0 to 180.0   \begin{itemize1}
+         \item    Positive values indicate eastern longitude
+         \item    Negative values indicate western longitude
+       \vspace{-0.18in} \end{itemize1} \end{itemize1} */
+
+  float horUncCircular;
+  /**<   Horizontal position uncertainty (circular).\n
+       - Units: Meters */
+
+  float speedHorizontal;
+  /**<   Horizontal speed.\n
+       - Units: Meters/second */
+
+  float speedUnc;
+  /**<   3-D Speed uncertainty.\n
+       - Units: Meters/second */
+
+  float altitudeWrtEllipsoid;
+  /**<   Altitude with respect to the WGS84 ellipsoid.\n
+       - Units: Meters \n
+       - Range: -500 to 15883 */
+
+  float speedVertical;
+  /**<   Vertical speed.\n
+         - Units: Meters/second */
+
+  float heading;
+  /**<   Heading.\n
+         - Units: Degrees \n
+         - Range: 0 to 359.999  */
+
+  float headingUnc;
+  /**<   Heading uncertainty.\n
+       - Units: Degrees \n
+       - Range: 0 to 359.999 */
+
+  qmiLocPosTechMaskT_v02 technologyMask;
+  /**<   Technology used in computing this fix.
+ Valid bitmasks: \n
+      - QMI_LOC_POS_TECH_MASK_SATELLITE (0x00000001) --  Satellites were used to generate the fix
+      - QMI_LOC_POS_TECH_MASK_CELLID (0x00000002) --  Cell towers were used to generate the fix
+      - QMI_LOC_POS_TECH_MASK_WIFI (0x00000004) --  Wi-Fi access points were used to generate the fix
+      - QMI_LOC_POS_TECH_MASK_SENSORS (0x00000008) --  Sensors were used to generate the fix
+      - QMI_LOC_POS_TECH_MASK_REFERENCE_LOCATION (0x00000010) --  Reference Location was used to generate the fix
+      - QMI_LOC_POS_TECH_MASK_INJECTED_COARSE_POSITION (0x00000020) --  Coarse position injected into the location engine was used to
+        generate the fix
+      - QMI_LOC_POS_TECH_MASK_AFLT (0x00000040) --  AFLT was used to generate the fix
+      - QMI_LOC_POS_TECH_MASK_HYBRID (0x00000080) --  GNSS and network-provided measurements were used to
+        generate the fix
+ */
+
+  uint64_t timestampUtc;
+  /**<   UTC timestamp. \n
+       - Units: Milliseconds since Jan. 1, 1970 */
+
+  float timeUnc;
+  /**<   Time uncertainty. \n
+       - Units: Milliseconds */
+
+  float magneticDeviation;
+  /**<   Difference between the bearing to true north and the bearing shown
+      on a magnetic compass. The deviation is positive when the magnetic
+      north is east of true north. */
+
+  float vertUnc;
+  /**<   Vertical uncertainty.\n
+       - Units: Meters */
+
+  uint8_t horConfidence;
+  /**<   Horizontal confidence.
+       - Units: Percent
+       - Range: 0 to 99 */
+
+  qmiLocGPSTimeStructT_v02 gpsTime;
+  /**<   Number of weeks since Jan. 5, 1980, and milliseconds into the current week. */
+}qmiLocBatchedReportStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used to notify the control point with the live batched
+                    position report. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Batched Position Report */
+  qmiLocBatchedReportStructT_v02 liveBatchedReport;
+  /**<   \n Live position report that is also batched. */
+}qmiLocEventLiveBatchedPositionReportIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to retrieve fixes from the batch. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Number of Fix Entries to be Retrieved from the Batch */
+  uint32_t numberOfEntries;
+  /**<   Number of fix entries to be retrieved from the batch. \n
+  Maximum limit -- QMI_LOC_READ_FROM_BATCH_MAX_SIZE.
+  */
+
+  /* Mandatory */
+  /*  Transaction ID */
+  uint32_t transactionId;
+  /**<   Identifies the transaction. The transaction ID is returned in the Read
+       from Batch indication. */
+}qmiLocReadFromBatchReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to retrieve fixes from the batch. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Read from Batch Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Read from Batch request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Mandatory */
+  /*  Transaction ID */
+  uint32_t transactionId;
+  /**<   Transaction ID that was specified in the Read from Batch
+       request.
+       */
+
+  /* Optional */
+  /*  Number of Fix Entries Returned from the Batch */
+  uint8_t numberOfEntries_valid;  /**< Must be set to true if numberOfEntries is being passed */
+  uint32_t numberOfEntries;
+  /**<   Number of fix entries returned from the batch. */
+
+  /* Optional */
+  /*  List of Batched Position Reports Returned */
+  uint8_t batchedReportList_valid;  /**< Must be set to true if batchedReportList is being passed */
+  uint32_t batchedReportList_len;  /**< Must be set to # of elements in batchedReportList */
+  qmiLocBatchedReportStructT_v02 batchedReportList[QMI_LOC_READ_FROM_BATCH_MAX_SIZE_V02];
+  /**<   \n List of fix reports returned from the batch. */
+}qmiLocReadFromBatchIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to stop an ongoing batching session. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Transaction ID */
+  uint32_t transactionId;
+  /**<   Transaction ID of the request. */
+
+  /* Optional */
+  /*  Request ID */
+  uint8_t requestId_valid;  /**< Must be set to true if requestId is being passed */
+  uint32_t requestId;
+  /**<   Identifies the batching request that must be stopped.
+       A batching client can start multiple batching requests. \n
+       Valid Values 0x01 - 0xFFFFFFFF
+  */
+}qmiLocStopBatchingReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to stop an ongoing batching session. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Stop Batching Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Stop Batching request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Mandatory */
+  /*  Transaction ID */
+  uint32_t transactionId;
+  /**<   Transaction ID that was specified in the Stop Batching request.
+  */
+
+  /* Optional */
+  /*  Request ID */
+  uint8_t requestId_valid;  /**< Must be set to true if requestId is being passed */
+  uint32_t requestId;
+  /**<   Identifies the batching request that was stopped.
+       A batching client can start multiple batching requests. \n
+       Valid Values 0x01 - 0xFFFFFFFF
+  */
+}qmiLocStopBatchingIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to release the batching buffer. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Transaction ID */
+  uint32_t transactionId;
+  /**<   Identifies the transaction. */
+}qmiLocReleaseBatchReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to release the batching buffer. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Release Batch Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Release Batch request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Mandatory */
+  /*  Transaction ID */
+  uint32_t transactionId;
+  /**<   Transaction ID that was specified in the Release Batch request.
+  */
+}qmiLocReleaseBatchIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Requests the control point to inject Wi-Fi AP data. */
+typedef struct {
+
+  /* Optional */
+  /*  E911 Mode */
+  uint8_t e911Mode_valid;  /**< Must be set to true if e911Mode is being passed */
+  uint8_t e911Mode;
+  /**<   Specifies whether GPS engine is in e911 mode when this
+       indication is sent to the client.
+
+       Valid values: \begin{itemize1}
+       \item    0x01 (TRUE) -- GPS engine is in e911 mode
+       \item    0x00 (FALSE) -- GPS engine is not in e911 mode
+       \end{itemize1}
+  */
+}qmiLocEventInjectWifiApDataReqIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCWIFIAPDATADEVICETYPEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_WIFI_AP_DATA_DEVICE_TYPE_WLAN_802_11_A_V02 = 0, /**<  Wi-Fi AP device is 802.11a.  */
+  eQMI_LOC_WIFI_AP_DATA_DEVICE_TYPE_WLAN_802_11_B_V02 = 1, /**<  Wi-Fi AP device is 802.11b.  */
+  eQMI_LOC_WIFI_AP_DATA_DEVICE_TYPE_WLAN_802_11_G_V02 = 2, /**<  Wi-Fi AP device is 802.11g.  */
+  QMILOCWIFIAPDATADEVICETYPEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocWifiApDataDeviceTypeEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCWIFIAPDATARTDUNITTYPEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_WIFI_AP_DATA_RTD_UNIT_MICROSEC_V02 = 0, /**<  Wi-Fi AP data Round-trip Delay (RTD) is in microseconds.  */
+  eQMI_LOC_WIFI_AP_DATA_RTD_UNIT_HUNDREDS_OF_NANOSEC_V02 = 1, /**<  Wi-Fi AP data RTD is in hundreds of nanoseconds.  */
+  eQMI_LOC_WIFI_AP_DATA_RTD_UNIT_TENS_OF_NANOSEC_V02 = 2, /**<  Wi-Fi AP data RTD is in tens of nanoseconds.  */
+  eQMI_LOC_WIFI_AP_DATA_RTD_UNIT_NANOSEC_V02 = 3, /**<  Wi-Fi AP data RTD is in nanoseconds.  */
+  eQMI_LOC_WIFI_AP_DATA_RTD_UNIT_TENTH_OF_NANOSEC_V02 = 4, /**<  Wi-Fi AP data RTD is in tenths of nanoseconds.  */
+  QMILOCWIFIAPDATARTDUNITTYPEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocWifiApDataRtdUnitTypeEnumT_v02;
+/**
+    @}
+  */
+
+typedef uint32_t qmiLocWifiApDataMaskT_v02;
+#define QMI_LOC_WIFI_APDATA_MASK_AP_TRANSMIT_POWER_V02 ((qmiLocWifiApDataMaskT_v02)0x00000001) /**<  AP transmit power is valid  */
+#define QMI_LOC_WIFI_APDATA_MASK_AP_ANTENNA_GAIN_V02 ((qmiLocWifiApDataMaskT_v02)0x00000002) /**<  AP antenna gain is valid  */
+#define QMI_LOC_WIFI_APDATA_MASK_AP_SNR_V02 ((qmiLocWifiApDataMaskT_v02)0x00000004) /**<  AP signal-to-noise ratio is valid  */
+#define QMI_LOC_WIFI_APDATA_MASK_AP_DEVICE_TYPE_V02 ((qmiLocWifiApDataMaskT_v02)0x00000008) /**<  AP device type is valid  */
+#define QMI_LOC_WIFI_APDATA_MASK_AP_RSSI_V02 ((qmiLocWifiApDataMaskT_v02)0x00000010) /**<  AP RSSI is valid  */
+#define QMI_LOC_WIFI_APDATA_MASK_AP_CHANNEL_V02 ((qmiLocWifiApDataMaskT_v02)0x00000020) /**<  AP channel is valid    */
+#define QMI_LOC_WIFI_APDATA_MASK_AP_ROUNDTRIP_DELAY_V02 ((qmiLocWifiApDataMaskT_v02)0x00000040) /**<  AP roundtrip delay is valid    */
+#define QMI_LOC_WIFI_APDATA_MASK_AP_ROUNDTRIP_DELAY_ACCURACY_V02 ((qmiLocWifiApDataMaskT_v02)0x00000080) /**<  AP roundtrip delay accuracy is valid   */
+#define QMI_LOC_WIFI_APDATA_MASK_MOBILE_SNR_V02 ((qmiLocWifiApDataMaskT_v02)0x00000100) /**<  Mobile signal-to-noise ratio is valid   */
+#define QMI_LOC_WIFI_APDATA_MASK_MOBILE_RSSI_V02 ((qmiLocWifiApDataMaskT_v02)0x00000200) /**<  Mobile RSSI is valid  */
+#define QMI_LOC_WIFI_APDATA_MASK_RSSI_TIMESTAMP_V02 ((qmiLocWifiApDataMaskT_v02)0x00000400) /**<  RSSI timestamp is valid  */
+#define QMI_LOC_WIFI_APDATA_MASK_MEASUREMENT_AGE_V02 ((qmiLocWifiApDataMaskT_v02)0x00000800) /**<  Measurement age is valid  */
+#define QMI_LOC_WIFI_APDATA_MASK_SERVING_AP_V02 ((qmiLocWifiApDataMaskT_v02)0x00001000) /**<  Serving access point is valid  */
+#define QMI_LOC_WIFI_APDATA_MASK_FREQUENCY_V02 ((qmiLocWifiApDataMaskT_v02)0x00002000) /**<  Channel frequency is valid  */
+#define QMI_LOC_WIFI_APDATA_MASK_SSID_V02 ((qmiLocWifiApDataMaskT_v02)0x00004000) /**<  SSID is valid  */
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  qmiLocWifiApDataMaskT_v02 wifiApDataMask;
+  /**<   Specifies which Wi-Fi AP scan information types are being used.
+
+ Valid values: \n
+      - QMI_LOC_WIFI_APDATA_MASK_AP_TRANSMIT_POWER (0x00000001) --  AP transmit power is valid
+      - QMI_LOC_WIFI_APDATA_MASK_AP_ANTENNA_GAIN (0x00000002) --  AP antenna gain is valid
+      - QMI_LOC_WIFI_APDATA_MASK_AP_SNR (0x00000004) --  AP signal-to-noise ratio is valid
+      - QMI_LOC_WIFI_APDATA_MASK_AP_DEVICE_TYPE (0x00000008) --  AP device type is valid
+      - QMI_LOC_WIFI_APDATA_MASK_AP_RSSI (0x00000010) --  AP RSSI is valid
+      - QMI_LOC_WIFI_APDATA_MASK_AP_CHANNEL (0x00000020) --  AP channel is valid
+      - QMI_LOC_WIFI_APDATA_MASK_AP_ROUNDTRIP_DELAY (0x00000040) --  AP roundtrip delay is valid
+      - QMI_LOC_WIFI_APDATA_MASK_AP_ROUNDTRIP_DELAY_ACCURACY (0x00000080) --  AP roundtrip delay accuracy is valid
+      - QMI_LOC_WIFI_APDATA_MASK_MOBILE_SNR (0x00000100) --  Mobile signal-to-noise ratio is valid
+      - QMI_LOC_WIFI_APDATA_MASK_MOBILE_RSSI (0x00000200) --  Mobile RSSI is valid
+      - QMI_LOC_WIFI_APDATA_MASK_RSSI_TIMESTAMP (0x00000400) --  RSSI timestamp is valid
+      - QMI_LOC_WIFI_APDATA_MASK_MEASUREMENT_AGE (0x00000800) --  Measurement age is valid
+      - QMI_LOC_WIFI_APDATA_MASK_SERVING_AP (0x00001000) --  Serving access point is valid
+      - QMI_LOC_WIFI_APDATA_MASK_FREQUENCY (0x00002000) --  Channel frequency is valid
+      - QMI_LOC_WIFI_APDATA_MASK_SSID (0x00004000) --  SSID is valid  */
+
+  uint8_t macAddress[QMI_LOC_WIFI_MAC_ADDR_LENGTH_V02];
+  /**<   MAC address. \n
+  Each address is of length QMI_LOC_WIFI_MAC_ADDR_LENGTH.
+  */
+
+  int32_t apTransmitPower;
+  /**<   AP transmit power in dBm.  */
+
+  int32_t apAntennaGain;
+  /**<   AP antenna gain in dBI. */
+
+  int32_t apSignalToNoise;
+  /**<   AP SNR received at the mobile device. */
+
+  qmiLocWifiApDataDeviceTypeEnumT_v02 apDeviceType;
+  /**<   List of AP device types. */
+
+  int32_t apRssi;
+  /**<   AP signal strength indicator in dBm. */
+
+  uint16_t apChannel;
+  /**<   AP Wi-Fi channel on which a beacon was received. */
+
+  uint32_t apRoundTripDelay;
+  /**<   Round trip delay between the mobile device and the AP, in units of
+       apRoundTripDelayUnit. */
+
+  qmiLocWifiApDataRtdUnitTypeEnumT_v02 apRoundTripDelayUnit;
+  /**<   Units of apRoundTripDelay and its accuracy; mandatory if apRoundTripDelay
+       is present. */
+
+  uint8_t apRoundTripDelayAccuracy;
+  /**<   AP's accuracy of round trip delay apRoundTripDelay, in units of
+       apRoundTripDelayUnit. */
+
+  int32_t mobileSignalToNoise;
+  /**<   Mobile SNR received at the AP. */
+
+  int32_t mobileRssi;
+  /**<   Mobile signal strength at the AP. */
+}qmiLocWifiApDataStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  int64_t rssiTimestamp;
+  /**<   Measurement time stamp, it is corresponding to when the beacon was received.
+       Units: Milliseconds \n
+       Type : int64 */
+
+  int32_t measAge;
+  /**<   Measurements age, -1 means info not available.
+       Units: Milliseconds \n
+       Type : int32 */
+
+  uint8_t servingAccessPoint;
+  /**<   This parameter indicates whether a set of WLAN-AP measurements
+       were obtained for a serving WLAN-AP (TRUE) or a non-serving WLAN-AP (FALSE).
+       A target device with multiple radio support may indicate more than
+       one type of serving access for the same time instant.
+       Type : boolean */
+
+  uint32_t channelFrequency;
+  /**<   Primary channel frequency.
+       Units: MHz \n
+       Type : uint32 */
+
+  char ssid[QMI_LOC_MAX_WIFI_AP_SSID_STR_LENGTH_V02 + 1];
+  /**<   The NULL-terminated SSID of the Wi-Fi AP.
+       Its maximum length according to the ASCII standard is 32 octets.
+       Type : string */
+
+  int32_t apHighResolutionRssi;
+  /**<   AP signal strength indicator in 0.1 dBm.
+       Units: 0.1dBm \n
+       Type : int32 */
+}qmiLocWifiApAdditionalDataStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCWLANAPERRENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_WLAN_AP_ERR_UNKNOWN_V02 = 0, /**<  Error is unknown  */
+  eQMI_LOC_WLAN_AP_ERR_NO_REQ_MEAS_AVAILABLE_V02 = 1, /**<  None of the requested measurements could be provided  */
+  eQMI_LOC_WLAN_AP_ERR_WIFI_OFF_V02 = 2, /**<  Wifi is off  */
+  QMILOCWLANAPERRENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocWlanApErrEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Injects Wi-Fi AP data. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Wi-Fi AP Scan Data */
+  uint32_t wifiApInfo_len;  /**< Must be set to # of elements in wifiApInfo */
+  qmiLocWifiApDataStructT_v02 wifiApInfo[QMI_LOC_WIFI_MAX_REPORTED_APS_PER_MSG_V02];
+  /**<   \n List of Wi-Fi AP scan information entered by the control point. */
+
+  /* Optional */
+  /*  The failure reason of WLAN-AP measurements not available  */
+  uint8_t errorCause_valid;  /**< Must be set to true if errorCause is being passed */
+  qmiLocWlanApErrEnumT_v02 errorCause;
+  /**<   In case of WLAN-AP measurements not available,
+ the appropriate reason for error/failure should be indicated.
+ This field won’t be present in the success case when WLAN-AP measurements are available.
+ Valid values: \n
+      - eQMI_LOC_WLAN_AP_ERR_UNKNOWN (0) --  Error is unknown
+      - eQMI_LOC_WLAN_AP_ERR_NO_REQ_MEAS_AVAILABLE (1) --  None of the requested measurements could be provided
+      - eQMI_LOC_WLAN_AP_ERR_WIFI_OFF (2) --  Wifi is off  */
+
+  /* Optional */
+  /*  Scan Request Timestamp */
+  uint8_t requestTimestamp_valid;  /**< Must be set to true if requestTimestamp is being passed */
+  int64_t requestTimestamp;
+  /**<   UTC timestamp at which the scan was requested.
+       Units: Milliseconds \n
+       Type : int64 */
+
+  /* Optional */
+  /*  Scan Receive Timestamp */
+  uint8_t receiveTimestamp_valid;  /**< Must be set to true if receiveTimestamp is being passed */
+  int64_t receiveTimestamp;
+  /**<   UTC timestamp at which the scan was received.
+       Units: Milliseconds \n
+       Type : int64 */
+
+  /* Optional */
+  /*  Free Scan or On-Demand Scan */
+  uint8_t onDemandScan_valid;  /**< Must be set to true if onDemandScan is being passed */
+  uint8_t onDemandScan;
+  /**<   If this scan is requested by the modem.
+        Type : boolean
+          0x00 (FALSE) -- The wifi AP data injection is not requested by the modem(Free Scan).
+          0x01 (TRUE) -- The wifi AP data injection is requested by the modem(On-Demand Scan).*/
+
+  /* Optional */
+  /*  Wi-Fi AP Additional Measurements Scan Data */
+  uint8_t wifiApInfoA_valid;  /**< Must be set to true if wifiApInfoA is being passed */
+  uint32_t wifiApInfoA_len;  /**< Must be set to # of elements in wifiApInfoA */
+  qmiLocWifiApAdditionalDataStructT_v02 wifiApInfoA[QMI_LOC_WIFI_MAX_REPORTED_APS_PER_MSG_V02];
+  /**<   \n List of Wi-Fi AP additional measurements scan information entered by the control point.
+          The order and the number of additional measurements must be as same as wifiApInfo */
+}qmiLocInjectWifiApDataReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Injects Wi-Fi AP data. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Wi-Fi AP Scan Information Injection Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Inject Wi-Fi AP Scan Information request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure  */
+}qmiLocInjectWifiApDataIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCWIFIACCESSPOINTATTACHSTATESENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_WIFI_ACCESS_POINT_ATTACHED_V02 = 0, /**<  Attached to an access point  */
+  eQMI_LOC_WIFI_ACCESS_POINT_DETACHED_V02 = 1, /**<  Detached from an access point  */
+  eQMI_LOC_WIFI_ACCESS_POINT_HANDOVER_V02 = 2, /**<  Handed over to another access point  */
+  QMILOCWIFIACCESSPOINTATTACHSTATESENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocWifiAccessPointAttachStatesEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to inject the Wi-Fi attachment status. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Attach State */
+  qmiLocWifiAccessPointAttachStatesEnumT_v02 attachState;
+  /**<   Wi.Fi access point attach state.
+
+ Valid values: \n
+      - eQMI_LOC_WIFI_ACCESS_POINT_ATTACHED (0) --  Attached to an access point
+      - eQMI_LOC_WIFI_ACCESS_POINT_DETACHED (1) --  Detached from an access point
+      - eQMI_LOC_WIFI_ACCESS_POINT_HANDOVER (2) --  Handed over to another access point  */
+
+  /* Optional */
+  /*  Access Point MAC Address */
+  uint8_t accessPointMacAddress_valid;  /**< Must be set to true if accessPointMacAddress is being passed */
+  uint8_t accessPointMacAddress[QMI_LOC_WIFI_MAC_ADDR_LENGTH_V02];
+  /**<   MAC address of the access point to which the Wi-Fi is attached.
+        This must always be specified if the attach state is Handover.
+        */
+
+  /* Optional */
+  /*  Wi-Fi AP SSID String */
+  uint8_t wifiApSsid_valid;  /**< Must be set to true if wifiApSsid is being passed */
+  char wifiApSsid[QMI_LOC_MAX_WIFI_AP_SSID_STR_LENGTH_V02 + 1];
+  /**<   The NULL-terminated SSID of the Wi-Fi AP. Its maximum length according to the ASCII standard is 32 octets. */
+}qmiLocNotifyWifiAttachmentStatusReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to inject the Wi-Fi attachment status. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Status of Wi-Fi Attachment Status Request */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of Wi-Fi Attachment Status request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure  */
+}qmiLocNotifyWifiAttachmentStatusIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCWIFIENABLEDSTATUSENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_WIFI_ENABLED_FALSE_V02 = 0, /**<  Wi-Fi is disabled on the device  */
+  eQMI_LOC_WIFI_ENABLED_TRUE_V02 = 1, /**<  Wi-Fi is enabled on the device  */
+  QMILOCWIFIENABLEDSTATUSENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocWifiEnabledStatusEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to inject the Wi-Fi enabled status. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Enabled Status */
+  qmiLocWifiEnabledStatusEnumT_v02 enabledStatus;
+  /**<   Wi-Fi enabled status on the device.
+
+ Valid values: \n
+      - eQMI_LOC_WIFI_ENABLED_FALSE (0) --  Wi-Fi is disabled on the device
+      - eQMI_LOC_WIFI_ENABLED_TRUE (1) --  Wi-Fi is enabled on the device  */
+}qmiLocNotifyWifiEnabledStatusReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to inject the Wi-Fi enabled status. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Status of Wi-Fi Enabled Status Request */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Wi-Fi Enabled Status request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure  */
+}qmiLocNotifyWifiEnabledStatusIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Notifies the control point whether the GNSS location engine is
+                    ready to accept vehicle data. */
+typedef struct {
+
+  /* Optional */
+  /*  Vehicle Accelerometer Ready Status */
+  uint8_t vehicleAccelReadyStatus_valid;  /**< Must be set to true if vehicleAccelReadyStatus is being passed */
+  uint8_t vehicleAccelReadyStatus;
+  /**<   The location service uses this TLV to let a control point know when it is
+       ready or not ready to receive vehicle accelerometer data input.
+       Values: \n
+       - 0x00 -- Not ready  \n
+       - 0x01 -- Ready */
+
+  /* Optional */
+  /*  Vehicle Angular Rate Ready Status */
+  uint8_t vehicleAngularRateReadyStatus_valid;  /**< Must be set to true if vehicleAngularRateReadyStatus is being passed */
+  uint8_t vehicleAngularRateReadyStatus;
+  /**<   The location service uses this TLV to let a control point know when it is
+       ready or not ready to receive vehicle angular rate data input.
+       Values: \n
+       - 0x00 -- Not ready \n
+       - 0x01 -- Ready */
+
+  /* Optional */
+  /*  Vehicle Odometry Ready Status */
+  uint8_t vehicleOdometryReadyStatus_valid;  /**< Must be set to true if vehicleOdometryReadyStatus is being passed */
+  uint8_t vehicleOdometryReadyStatus;
+  /**<   The location service uses this TLV to let a control point know when it is
+       ready or not ready to receive vehicle odometry data input.
+       Values: \n
+       - 0x00 -- Not ready \n
+       - 0x01 -- Ready*/
+}qmiLocEventVehicleDataReadyIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint32_t timeOffset;
+  /**<   Sample time offset. This time offset must be
+       relative to the vehicle sensor time of the first sample. \n
+       - Units: Microseconds \n
+       - Range: Up to over 4000 seconds */
+
+  uint32_t axisSample_len;  /**< Must be set to # of elements in axisSample */
+  float axisSample[QMI_LOC_VEHICLE_SENSOR_DATA_MAX_AXES_V02];
+  /**<   Sensor axis sample.        \n
+       - Type: Floating point     \n
+       - Units accelerometer: Meters/seconds^2 \n
+       - Units gyroscope: Radians/seconds \vspace{4pt}
+
+       Note: The axes samples must be in the following order: \n
+             1. X-Axis \n
+             2. Y-Axis \n
+             3. Z-Axis */
+}qmiLocVehicleSensorSampleStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+typedef uint8_t qmiLocAxesMaskT_v02;
+#define QMI_LOC_MASK_X_AXIS_V02 ((qmiLocAxesMaskT_v02)0x01) /**<  X-axis is valid  */
+#define QMI_LOC_MASK_Y_AXIS_V02 ((qmiLocAxesMaskT_v02)0x02) /**<  Y-axis is valid  */
+#define QMI_LOC_MASK_Z_AXIS_V02 ((qmiLocAxesMaskT_v02)0x04) /**<  Z-axis is valid  */
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint32_t sampleTimeBase;
+  /**<   Denotes a 32-bit time tag of the reference time from which
+       all samples in this message are offset. This time must
+       be the same as or (slightly) earlier than the first (oldest)
+       sample in this message. \n
+       - Units: Milliseconds \n
+       - Range: Approx. 4 million seconds, or almost 50 days between rollovers */
+
+  qmiLocAxesMaskT_v02 axesValidity;
+  /**<   Identifies the axes that are valid for all sensor samples.
+
+ Valid values: \n
+      - QMI_LOC_MASK_X_AXIS (0x01) --  X-axis is valid
+      - QMI_LOC_MASK_Y_AXIS (0x02) --  Y-axis is valid
+      - QMI_LOC_MASK_Z_AXIS (0x04) --  Z-axis is valid  */
+
+  uint32_t sensorData_len;  /**< Must be set to # of elements in sensorData */
+  qmiLocVehicleSensorSampleStructT_v02 sensorData[QMI_LOC_VEHICLE_SENSOR_DATA_MAX_SAMPLES_V02];
+}qmiLocVehicleSensorSampleListStructType_v02;  /* Type */
+/**
+    @}
+  */
+
+typedef uint32_t qmiLocVehicleOdometryMeasDeviationMaskType_v02;
+#define QMI_LOC_MASK_VEHICLE_ODOMETRY_REVERSE_MOVEMENT_V02 ((qmiLocVehicleOdometryMeasDeviationMaskType_v02)0x00000001) /**<  Odometry data in this message includes at least some data where
+       the vehicle may have been moving in the reverse direction; this
+       bit must be set if odometry data may be in reverse, and should
+       not be set if odometry data is all in the forward direction  */
+#define QMI_LOC_MASK_VEHICLE_ODOMETRY_AFFECTED_BY_ERRORS_V02 ((qmiLocVehicleOdometryMeasDeviationMaskType_v02)0x00000002) /**<  Odometry data in this message includes at least some data affected
+       by a major error source affecting distance-travelled accuracy,
+       such as wheel slippage due to skidding, gravel, snow, or ice, as
+       detected by the vehicle, e.g., via an ABS or other system  */
+#define QMI_LOC_MASK_VEHICLE_ODOMETRY_ABSOLUTE_MEASUREMENT_V02 ((qmiLocVehicleOdometryMeasDeviationMaskType_v02)0x00000004) /**<  Odometry data in this message is an absolute amount since the vehicle
+       began service, and is the same vehicle that is regularly used with
+       this device (so that the offset of this value, since the last time
+       this measurement was used by the location engine, can safely be used
+       as a likely correct estimate of distance travelled since last
+       use)  */
+typedef uint32_t qmiLocVehicleOdometryWheelFlagsMaskT_v02;
+#define QMI_LOC_MASK_VEHICLE_ODOMETRY_LEFT_AND_RIGHT_AVERAGE_V02 ((qmiLocVehicleOdometryWheelFlagsMaskT_v02)0x00000001) /**<  Average of left and right non-turning wheels  */
+#define QMI_LOC_MASK_VEHICLE_ODOMETRY_LEFT_V02 ((qmiLocVehicleOdometryWheelFlagsMaskT_v02)0x00000002) /**<  Left side, non-turning wheel  */
+#define QMI_LOC_MASK_VEHICLE_ODOMETRY_RIGHT_V02 ((qmiLocVehicleOdometryWheelFlagsMaskT_v02)0x00000004) /**<  Right side, non-turning wheel  */
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint32_t timeOffset;
+  /**<   Sample time offset. This time offset must be
+       relative to the sensor time of the first sample. \n
+       - Units: Microseconds \n
+       - Range: Up to over 4000 seconds */
+
+  uint32_t distanceTravelled_len;  /**< Must be set to # of elements in distanceTravelled */
+  uint32_t distanceTravelled[QMI_LOC_VEHICLE_ODOMETRY_MAX_MEASUREMENTS_V02];
+  /**<    Distance travelled (odometry) sample offset. \n
+        - Units of accumulated distance: Millimeters \n
+        - Range: Over 4000 kilometers
+
+        This measurement (with units in millimeters) is added to
+        the distance_travelled_base measurement (in meters) to
+        get the total distance travelled sample value.
+
+        Note: The order of measurements must be as follows: \n
+        1. Left and right average \n
+        2. Left \n
+        3. Right
+   */
+}qmiLocVehicleOdometrySampleStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint32_t sampleTimeBase;
+  /**<   Denotes a 32-bit time tag of a reference time, from which
+       all samples in this message are offset.  Note this time must
+       be the same or (slightly) earlier than the first (oldest)
+       sample in this message. \n
+       - Units: 1 millisecond \n
+       - Range: ~4 million seconds, or almost 50 days between rollovers */
+
+  qmiLocVehicleOdometryMeasDeviationMaskType_v02 flags;
+  /**<   Flags to indicate any deviation from the default measurement
+ assumptions. Valid bitmasks: \n
+      - QMI_LOC_MASK_VEHICLE_ODOMETRY_REVERSE_MOVEMENT (0x00000001) --  Odometry data in this message includes at least some data where
+       the vehicle may have been moving in the reverse direction; this
+       bit must be set if odometry data may be in reverse, and should
+       not be set if odometry data is all in the forward direction
+      - QMI_LOC_MASK_VEHICLE_ODOMETRY_AFFECTED_BY_ERRORS (0x00000002) --  Odometry data in this message includes at least some data affected
+       by a major error source affecting distance-travelled accuracy,
+       such as wheel slippage due to skidding, gravel, snow, or ice, as
+       detected by the vehicle, e.g., via an ABS or other system
+      - QMI_LOC_MASK_VEHICLE_ODOMETRY_ABSOLUTE_MEASUREMENT (0x00000004) --  Odometry data in this message is an absolute amount since the vehicle
+       began service, and is the same vehicle that is regularly used with
+       this device (so that the offset of this value, since the last time
+       this measurement was used by the location engine, can safely be used
+       as a likely correct estimate of distance travelled since last
+       use)  */
+
+  qmiLocVehicleOdometryWheelFlagsMaskT_v02 wheelFlags;
+  /**<   Delineates for which wheels measurements are being provided
+ in the following samples, where one or more of the following
+ bits must be set, and data samples aligned with these axes must
+ appear in groups, in this order.
+
+ Valid bitmasks: \n
+      - QMI_LOC_MASK_VEHICLE_ODOMETRY_LEFT_AND_RIGHT_AVERAGE (0x00000001) --  Average of left and right non-turning wheels
+      - QMI_LOC_MASK_VEHICLE_ODOMETRY_LEFT (0x00000002) --  Left side, non-turning wheel
+      - QMI_LOC_MASK_VEHICLE_ODOMETRY_RIGHT (0x00000004) --  Right side, non-turning wheel  */
+
+  uint32_t distanceTravelledBase;
+  /**<   Distance traveled base. \n
+        - Units of accumulated distance: Meters \n
+        - Range: Over 4,000,0000 kilometers \vspace{0.06in} \n
+
+        Distance travelled (odometry) is to be reported in a continuously
+        accumulating way from device power up. It may be incremental distance
+        starting at 0, or another arbitrary point, from device power up, or the
+        absolute distance traveled by the vehicle
+        (and if so, set QMI_LOC_MASK_VEHICLE_ODOMETRY_ABSOLUTE_MEASUREMENT),
+        as long as it grows incrementally from device power up.
+
+        This distance_travelled_base is added to the distrance_travelled_offset
+        of each sample (below) to get the absolute distance of each sample
+        point.
+
+        Distance travelled errors are expected to be primarily due to the
+        scale factor, with some allowance for noise due to minor slippage
+        events (e.g., gravel.)
+        Major wheel slippage events that affect odometry
+        must be flagged -- see the flags field.
+
+        Note that other events, such as a vehicle travelling in reverse, may
+        also affect the available accuracy of this information, and notification
+        of those events must be provided -- see the flags field. */
+
+  uint32_t odometryData_len;  /**< Must be set to # of elements in odometryData */
+  qmiLocVehicleOdometrySampleStructT_v02 odometryData[QMI_LOC_VEHICLE_SENSOR_DATA_MAX_SAMPLES_V02];
+  /**<   Variable length array to specify the odometry samples.
+       Maximum length of the array is 50. */
+}qmiLocVehicleOdometrySampleListStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Injects on-vehicle sensor data into the location engine. */
+typedef struct {
+
+  /* Optional */
+  /*  On-Vehicle Accelerometer Data */
+  uint8_t accelData_valid;  /**< Must be set to true if accelData is being passed */
+  qmiLocVehicleSensorSampleListStructType_v02 accelData;
+  /**<   \vspace{0.06in} \n Vehicle accelerometer sensor samples. */
+
+  /* Optional */
+  /*  On-Vehicle Angular Rotation Data */
+  uint8_t angRotationData_valid;  /**< Must be set to true if angRotationData is being passed */
+  qmiLocVehicleSensorSampleListStructType_v02 angRotationData;
+  /**<   \vspace{0.06in} \n Vehicle angular rotation data sensor samples. */
+
+  /* Optional */
+  /*  Odometry Data */
+  uint8_t odometryData_valid;  /**< Must be set to true if odometryData is being passed */
+  qmiLocVehicleOdometrySampleListStructT_v02 odometryData;
+  /**<   \vspace{0.06in} \n Odometer sensor samples. */
+
+  /* Optional */
+  /*  External Time Sync Information */
+  uint8_t changeInTimeScales_valid;  /**< Must be set to true if changeInTimeScales is being passed */
+  int32_t changeInTimeScales;
+  /**<   This field is to be used in conjunction with an external
+       time-sync mechanism that is aligning the vehicle sensor time scale
+       with the on-device sensor time scale to ensure that updates in
+       that time offset do not appear as jumps in the relative sensor time
+       of the samples provided in this message. If there is no such sync
+       mechanism, e.g., if only the vehicle time is provided, this field
+       may be left at 0.
+
+       This field is defined as the change from the previously-sent QMI
+       message with similar TLVs 0x10, 0x11, or 0x12 in it, to this QMI
+       message in the amount that the sensor_time is ahead of an
+       external vehicle time. \n
+
+       - Units: Microseconds \n
+       - Range: Approximately -2100 seconds to + 2100 seconds, where
+                full-scale (minimum and maximum value) is interpreted
+                as equal to or greater than this value of an offset change
+                (unlikely to be reached in practice, unless there is a
+                startup, major resync, or some other rollover event). */
+}qmiLocInjectVehicleSensorDataReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Injects on-vehicle sensor data into the location engine. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Inject Vehicle Sensor Data Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Inject Vehicle Sensor Data request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure  */
+}qmiLocInjectVehicleSensorDataIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to get the first available WWAN
+                    position from the location engine. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Transaction ID */
+  uint32_t transactionId;
+  /**<   Identifies the transaction. The transaction ID
+       is returned in the Get Available WWAN Position indication. */
+}qmiLocGetAvailWwanPositionReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to get the first available WWAN
+                    position from the location engine. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Get Available WWAN Position Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Get Available WWAN Position request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure  */
+
+  /* Optional */
+  /*  Transaction ID */
+  uint8_t transactionId_valid;  /**< Must be set to true if transactionId is being passed */
+  uint32_t transactionId;
+  /**<   Transaction ID that was specified in the Get Available
+       WWAN Position request. This parameter will
+       always be present if the status field is set to
+       SUCCESS. */
+
+  /* Optional */
+  /*  Latitude */
+  uint8_t latitude_valid;  /**< Must be set to true if latitude is being passed */
+  double latitude;
+  /**<   Latitude (specified in WGS84 datum).
+       \begin{itemize1}
+       \item    Type: Floating point
+       \item    Units: Degrees
+       \item     Range: -90.0 to 90.0      \begin{itemize1}
+         \item    Positive values indicate northern latitude
+         \item    Negative values indicate southern latitude
+       \vspace{-0.18in} \end{itemize1} \end{itemize1} */
+
+  /* Optional */
+  /*  Longitude */
+  uint8_t longitude_valid;  /**< Must be set to true if longitude is being passed */
+  double longitude;
+  /**<   Longitude (specified in WGS84 datum).
+       \begin{itemize1}
+       \item    Type: Floating point
+       \item    Units: Degrees
+       \item    Range: -180.0 to 180.0     \begin{itemize1}
+         \item    Positive values indicate eastern longitude
+         \item    Negative values indicate western longitude
+       \vspace{-0.18in} \end{itemize1} \end{itemize1} */
+
+  /* Optional */
+  /*  Circular Horizontal Position Uncertainty */
+  uint8_t horUncCircular_valid;  /**< Must be set to true if horUncCircular is being passed */
+  float horUncCircular;
+  /**<   Horizontal position uncertainty (circular).\n
+       - Units: Meters */
+
+  /* Optional */
+  /*  Altitude With Respect to Ellipsoid */
+  uint8_t altitudeWrtEllipsoid_valid;  /**< Must be set to true if altitudeWrtEllipsoid is being passed */
+  float altitudeWrtEllipsoid;
+  /**<   Altitude with respect to the WGS84 ellipsoid.\n
+       - Units: Meters \n
+       - Range: -500 to 15883 */
+
+  /* Optional */
+  /*  Vertical Uncertainty */
+  uint8_t vertUnc_valid;  /**< Must be set to true if vertUnc is being passed */
+  float vertUnc;
+  /**<   Vertical uncertainty.\n
+       - Units: Meters */
+
+  /* Optional */
+  /*  UTC Timestamp */
+  uint8_t timestampUtc_valid;  /**< Must be set to true if timestampUtc is being passed */
+  uint64_t timestampUtc;
+  /**<   UTC timestamp. \n
+       - Units: Milliseconds since Jan. 1, 1970 */
+
+  /* Optional */
+  /*  Time Uncertainty */
+  uint8_t timeUnc_valid;  /**< Must be set to true if timeUnc is being passed */
+  float timeUnc;
+  /**<   Time uncertainty. \n
+       - Units: Milliseconds */
+
+  /* Optional */
+  /*  Horizontal Elliptical Uncertainty Semi-Minor Axis */
+  uint8_t horUncEllipseSemiMinor_valid;  /**< Must be set to true if horUncEllipseSemiMinor is being passed */
+  float horUncEllipseSemiMinor;
+  /**<   Semi-minor axis of horizontal elliptical uncertainty. \n
+       - Units: Meters */
+
+  /* Optional */
+  /*  Horizontal Elliptical Uncertainty Semi-Major Axis */
+  uint8_t horUncEllipseSemiMajor_valid;  /**< Must be set to true if horUncEllipseSemiMajor is being passed */
+  float horUncEllipseSemiMajor;
+  /**<   Semi-major axis of horizontal elliptical uncertainty. \n
+       - Units: Meters */
+
+  /* Optional */
+  /*  Horizontal Elliptical Uncertainty Azimuth */
+  uint8_t horUncEllipseOrientAzimuth_valid;  /**< Must be set to true if horUncEllipseOrientAzimuth is being passed */
+  float horUncEllipseOrientAzimuth;
+  /**<   Elliptical horizontal uncertainty azimuth of orientation. \n
+       - Units: Decimal degrees \n
+       - Range: 0 to 180 */
+
+  /* Optional */
+  /*  Horizontal Circular Confidence */
+  uint8_t horCircularConfidence_valid;  /**< Must be set to true if horCircularConfidence is being passed */
+  uint8_t horCircularConfidence;
+  /**<   Horizontal circular uncertainty confidence. \n
+       - Units: Percent \n
+       - Range: 0 to 99 */
+
+  /* Optional */
+  /*  Horizontal Elliptical Confidence */
+  uint8_t horEllipticalConfidence_valid;  /**< Must be set to true if horEllipticalConfidence is being passed */
+  uint8_t horEllipticalConfidence;
+  /**<   Horizontal elliptical uncertainty confidence. \n
+       - Units: Percent \n
+       - Range: 0 to 99 */
+
+  /* Optional */
+  /*  Horizontal Reliability */
+  uint8_t horReliability_valid;  /**< Must be set to true if horReliability is being passed */
+  qmiLocReliabilityEnumT_v02 horReliability;
+  /**<   Specifies the reliability of the horizontal position.
+ Valid values: \n
+      - eQMI_LOC_RELIABILITY_NOT_SET (0) --  Location reliability is not set
+      - eQMI_LOC_RELIABILITY_VERY_LOW (1) --  Location reliability is very low; use it at your own risk
+      - eQMI_LOC_RELIABILITY_LOW (2) --  Location reliability is low; little or no cross-checking is possible
+      - eQMI_LOC_RELIABILITY_MEDIUM (3) --  Location reliability is medium; limited cross-check passed
+      - eQMI_LOC_RELIABILITY_HIGH (4) --  Location reliability is high; strong cross-check passed
+ */
+
+  /* Optional */
+  /*  Altitude With Respect to Sea Level */
+  uint8_t altitudeWrtMeanSeaLevel_valid;  /**< Must be set to true if altitudeWrtMeanSeaLevel is being passed */
+  float altitudeWrtMeanSeaLevel;
+  /**<   Altitude with respect to mean sea level. \n
+       - Units: Meters */
+
+  /* Optional */
+  /*  Vertical Confidence */
+  uint8_t vertConfidence_valid;  /**< Must be set to true if vertConfidence is being passed */
+  uint8_t vertConfidence;
+  /**<   Vertical uncertainty confidence. \n
+       - Units: Percent \n
+       - Range: 0 to 99 */
+
+  /* Optional */
+  /*  Vertical Reliability */
+  uint8_t vertReliability_valid;  /**< Must be set to true if vertReliability is being passed */
+  qmiLocReliabilityEnumT_v02 vertReliability;
+  /**<   Specifies the reliability of the vertical position.
+
+ Valid values: \n
+      - eQMI_LOC_RELIABILITY_NOT_SET (0) --  Location reliability is not set
+      - eQMI_LOC_RELIABILITY_VERY_LOW (1) --  Location reliability is very low; use it at your own risk
+      - eQMI_LOC_RELIABILITY_LOW (2) --  Location reliability is low; little or no cross-checking is possible
+      - eQMI_LOC_RELIABILITY_MEDIUM (3) --  Location reliability is medium; limited cross-check passed
+      - eQMI_LOC_RELIABILITY_HIGH (4) --  Location reliability is high; strong cross-check passed
+ */
+
+  /* Optional */
+  /*  GPS Time */
+  uint8_t gpsTime_valid;  /**< Must be set to true if gpsTime is being passed */
+  qmiLocGPSTimeStructT_v02 gpsTime;
+
+  /* Optional */
+  /*  Time Source */
+  uint8_t timeSrc_valid;  /**< Must be set to true if timeSrc is being passed */
+  qmiLocTimeSourceEnumT_v02 timeSrc;
+  /**<   Time source.
+
+ Valid values: \n
+      - eQMI_LOC_TIME_SRC_INVALID (0) --  Invalid time.
+      - eQMI_LOC_TIME_SRC_NETWORK_TIME_TRANSFER (1) --  Time is set by the 1X system
+      - eQMI_LOC_TIME_SRC_NETWORK_TIME_TAGGING (2) --  Time is set by WCDMA/GSM time tagging (that is,
+       associating network time with GPS time)
+      - eQMI_LOC_TIME_SRC_EXTERNAL_INPUT (3) --  Time is set by an external injection
+      - eQMI_LOC_TIME_SRC_TOW_DECODE (4) --  Time is set after decoding over-the-air GPS navigation data
+       from one GPS satellite
+      - eQMI_LOC_TIME_SRC_TOW_CONFIRMED (5) --  Time is set after decoding over-the-air GPS navigation data
+       from multiple satellites
+      - eQMI_LOC_TIME_SRC_TOW_AND_WEEK_CONFIRMED (6) --  Both time of the week and the GPS week number are known
+      - eQMI_LOC_TIME_SRC_NAV_SOLUTION (7) --  Time is set by the position engine after the fix is obtained
+      - eQMI_LOC_TIME_SRC_SOLVE_FOR_TIME (8) --  Time is set by the position engine after performing SFT;
+       this is done when the clock time uncertainty is large
+      - eQMI_LOC_TIME_SRC_GLO_TOW_DECODE (9) --  Time is set after decoding GLO satellites
+      - eQMI_LOC_TIME_SRC_TIME_TRANSFORM (10) --  Time is set after transforming the GPS to GLO time
+      - eQMI_LOC_TIME_SRC_WCDMA_SLEEP_TIME_TAGGING (11) --  Time is set by the sleep time tag provided by the WCDMA network
+      - eQMI_LOC_TIME_SRC_GSM_SLEEP_TIME_TAGGING (12) --  Time is set by the sleep time tag provided by the GSM network
+      - eQMI_LOC_TIME_SRC_UNKNOWN (13) --  Source of the time is unknown
+      - eQMI_LOC_TIME_SRC_SYSTEM_TIMETICK (14) --  Time is derived from the system clock (better known as the slow clock);
+       GNSS time is maintained irrespective of the GNSS receiver state
+      - eQMI_LOC_TIME_SRC_QZSS_TOW_DECODE (15) --  Time is set after decoding QZSS satellites
+      - eQMI_LOC_TIME_SRC_BDS_TOW_DECODE (16) --  Time is set after decoding BDS satellites
+      - eQMI_LOC_TIME_SRC_GAL_TOW_DECODE (17) --  Time is set after decoding GAL satellites
+ */
+}qmiLocGetAvailWwanPositionIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCPREMIUMSERVICEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_PREMIUM_SERVICE_GTP_CELL_V02 = 0, /**<  Premium service -- Global terrestrial positioning for the cell  */
+  eQMI_LOC_PREMIUM_SERVICE_SAP_V02 = 1, /**<  Premium service -- Sensor-assisted positioning  */
+  eQMI_LOC_PREMIUM_SERVICE_GTP_ENH_CELL_V02 = 2, /**<  Premium service -- Global terrestrial positioning enhanced cell  */
+  eQMI_LOC_PREMIUM_SERVICE_GTP_WIFI_V02 = 3, /**<  Premium service -- Global terrestrial positioning for the WIFI  */
+  QMILOCPREMIUMSERVICEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocPremiumServiceEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCPREMIUMSERVICECFGENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_PREMIUM_SERVICE_DISABLED_V02 = 0, /**<  Premium service disabled  */
+  eQMI_LOC_PREMIUM_SERVICE_ENABLED_BASIC_V02 = 1, /**<  Premium service enabled for basic  */
+  eQMI_LOC_PREMIUM_SERVICE_ENABLED_PREMIUM_V02 = 2, /**<  Premium service enabled for premium  */
+  QMILOCPREMIUMSERVICECFGENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocPremiumServiceCfgEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to set the configuration */
+typedef struct {
+
+  /* Mandatory */
+  /*  Set Premium Service Type */
+  qmiLocPremiumServiceEnumT_v02 premiumServiceType;
+  /**<   Specifies the premium service to configure.
+
+ Valid values: \n
+      - eQMI_LOC_PREMIUM_SERVICE_GTP_CELL (0) --  Premium service -- Global terrestrial positioning for the cell
+      - eQMI_LOC_PREMIUM_SERVICE_SAP (1) --  Premium service -- Sensor-assisted positioning
+      - eQMI_LOC_PREMIUM_SERVICE_GTP_ENH_CELL (2) --  Premium service -- Global terrestrial positioning enhanced cell
+      - eQMI_LOC_PREMIUM_SERVICE_GTP_WIFI (3) --  Premium service -- Global terrestrial positioning for the WIFI
+ */
+
+  /* Mandatory */
+  /*  Set Premium Service Configuration */
+  qmiLocPremiumServiceCfgEnumT_v02 premiumServiceCfg;
+  /**<   Specifies the premium service configuration mode.
+
+ Valid values: \n
+      - eQMI_LOC_PREMIUM_SERVICE_DISABLED (0) --  Premium service disabled
+      - eQMI_LOC_PREMIUM_SERVICE_ENABLED_BASIC (1) --  Premium service enabled for basic
+      - eQMI_LOC_PREMIUM_SERVICE_ENABLED_PREMIUM (2) --  Premium service enabled for premium
+ */
+}qmiLocSetPremiumServicesCfgReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to set the configuration */
+typedef struct {
+
+  /* Mandatory */
+  /*  Set Premium Service Configuration Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Set Premium Services Configuration request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure  */
+}qmiLocSetPremiumServicesCfgIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCXTRAVERSIONCHECKENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_XTRA_VERSION_CHECK_DISABLE_V02 = 0, /**<  XTRA file version check is not required   */
+  eQMI_LOC_XTRA_VERSION_CHECK_AUTO_V02 = 1, /**<  XTRA file version check is required; the Location service decides the 'expected version' based on the preprovisioned XTRA version configuration  */
+  eQMI_LOC_XTRA_VERSION_CHECK_XTRA2_V02 = 2, /**<  Check the XTRA file against XTRA2 format  */
+  eQMI_LOC_XTRA_VERSION_CHECK_XTRA3_V02 = 3, /**<  Check the XTRA file against XTRA3 format  */
+  eQMI_LOC_XTRA_VERSION_CHECK_XTRA3_1_V02 = 4, /**<  Check the XTRA file against XTRA3.1 format  */
+  QMILOCXTRAVERSIONCHECKENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocXtraVersionCheckEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to enable or disable XTRA version
+                    verification. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Set XTRA Version Check Mode */
+  qmiLocXtraVersionCheckEnumT_v02 xtraVersionCheckMode;
+  /**<   Specifies XTRA version check mode.
+
+ Valid values: \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_DISABLE (0) --  XTRA file version check is not required
+      - eQMI_LOC_XTRA_VERSION_CHECK_AUTO (1) --  XTRA file version check is required; the Location service decides the 'expected version' based on the preprovisioned XTRA version configuration
+      - eQMI_LOC_XTRA_VERSION_CHECK_XTRA2 (2) --  Check the XTRA file against XTRA2 format
+      - eQMI_LOC_XTRA_VERSION_CHECK_XTRA3 (3) --  Check the XTRA file against XTRA3 format
+      - eQMI_LOC_XTRA_VERSION_CHECK_XTRA3_1 (4) --  Check the XTRA file against XTRA3.1 format
+ */
+}qmiLocSetXtraVersionCheckReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to enable or disable XTRA version
+                    verification. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Set XTRA Version Check Mode Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Set XTRA version check request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure  */
+}qmiLocSetXtraVersionCheckIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+typedef uint64_t qmiLocGNSSConstellEnumT_v02;
+#define eQMI_SYSTEM_GPS_V02 ((qmiLocGNSSConstellEnumT_v02)0x01ull) /**<  Enable GPS \n  */
+#define eQMI_SYSTEM_GLO_V02 ((qmiLocGNSSConstellEnumT_v02)0x02ull) /**<  Enable GLONASS \n  */
+#define eQMI_SYSTEM_BDS_V02 ((qmiLocGNSSConstellEnumT_v02)0x04ull) /**<  Enable BDS \n  */
+#define eQMI_SYSTEM_GAL_V02 ((qmiLocGNSSConstellEnumT_v02)0x08ull) /**<  Enable Galileo  */
+#define eQMI_SYSTEM_QZSS_V02 ((qmiLocGNSSConstellEnumT_v02)0x10ull) /**<  Enable QZSS  */
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Sets satellite constellations of interest for reporting. */
+typedef struct {
+
+  /* Optional */
+  /*  GNSS Measurement Report Constellation Control */
+  uint8_t measReportConfig_valid;  /**< Must be set to true if measReportConfig is being passed */
+  qmiLocGNSSConstellEnumT_v02 measReportConfig;
+  /**<   GNSS measurement report constellation control. \n
+ Valid values: \n
+      - eQMI_SYSTEM_GPS (0x01) --  Enable GPS \n
+      - eQMI_SYSTEM_GLO (0x02) --  Enable GLONASS \n
+      - eQMI_SYSTEM_BDS (0x04) --  Enable BDS \n
+      - eQMI_SYSTEM_GAL (0x08) --  Enable Galileo
+      - eQMI_SYSTEM_QZSS (0x10) --  Enable QZSS
+ */
+
+  /* Optional */
+  /*  SV Polynomial Report Constellation Control */
+  uint8_t svPolyReportConfig_valid;  /**< Must be set to true if svPolyReportConfig is being passed */
+  qmiLocGNSSConstellEnumT_v02 svPolyReportConfig;
+  /**<   SV polynomial report constellation control. \n
+ Valid values: \n
+      - eQMI_SYSTEM_GPS (0x01) --  Enable GPS \n
+      - eQMI_SYSTEM_GLO (0x02) --  Enable GLONASS \n
+      - eQMI_SYSTEM_BDS (0x04) --  Enable BDS \n
+      - eQMI_SYSTEM_GAL (0x08) --  Enable Galileo
+      - eQMI_SYSTEM_QZSS (0x10) --  Enable QZSS
+ */
+}qmiLocSetGNSSConstRepConfigReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Sets satellite constellations of interest for reporting. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Set GNSS Constellation Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the GNSS constellation.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+}qmiLocSetGNSSConstRepConfigIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCSOURCEOFFREQENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_FREQ_SOURCE_INVALID_V02 = 0, /**<  Source of the frequency is invalid  */
+  eQMI_LOC_FREQ_SOURCE_EXTERNAL_V02 = 1, /**<  Source of the frequency is from an external injection  */
+  eQMI_LOC_FREQ_SOURCE_PE_CLK_REPORT_V02 = 2, /**<  Source of the frequency is from the GNSS navigation engine  */
+  eQMI_LOC_FREQ_SOURCE_UNKNOWN_V02 = 3, /**<  Source of the frequency is unknown  */
+  QMILOCSOURCEOFFREQENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocSourceofFreqEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  float clockDrift;
+  /**<   Receiver clock drift. \n
+         - Units: Meters per second
+    */
+
+  float clockDriftUnc;
+  /**<   Receiver clock drift uncertainty. \n
+         - Units: Meters per second
+    */
+
+  qmiLocSourceofFreqEnumT_v02 sourceOfFreq;
+  /**<   Source of the clock frequency information.
+
+ Valid values: \n
+      - eQMI_LOC_FREQ_SOURCE_INVALID (0) --  Source of the frequency is invalid
+      - eQMI_LOC_FREQ_SOURCE_EXTERNAL (1) --  Source of the frequency is from an external injection
+      - eQMI_LOC_FREQ_SOURCE_PE_CLK_REPORT (2) --  Source of the frequency is from the GNSS navigation engine
+      - eQMI_LOC_FREQ_SOURCE_UNKNOWN (3) --  Source of the frequency is unknown
+ */
+}qmiLocRcvrClockFrequencyInfoStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint8_t leapSec;
+  /**<   GPS time leap second delta to UTC time.  \n
+         For nonzero values of leapSecUnc, leapSec must be treated as unknown. \n
+             - Units: Seconds
+    */
+
+  uint8_t leapSecUnc;
+  /**<   Uncertainty for the GPS leap second. \n
+             - Units: Seconds
+    */
+}qmiLocLeapSecondInfoStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+typedef uint8_t qmiLocInterSystemBiasValidMaskT_v02;
+#define QMI_LOC_SYS_TIME_BIAS_VALID_V02 ((qmiLocInterSystemBiasValidMaskT_v02)0x01) /**<  System time bias is valid \n  */
+#define QMI_LOC_SYS_TIME_BIAS_UNC_VALID_V02 ((qmiLocInterSystemBiasValidMaskT_v02)0x02) /**<  System time bias uncertainty is valid  */
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  qmiLocInterSystemBiasValidMaskT_v02 validMask;
+  /**<   Fields that are valid. \n
+ Valid values: \n
+      - QMI_LOC_SYS_TIME_BIAS_VALID (0x01) --  System time bias is valid \n
+      - QMI_LOC_SYS_TIME_BIAS_UNC_VALID (0x02) --  System time bias uncertainty is valid  \n
+ */
+
+  float timeBias;
+  /**<   System 1 to System 2 time bias.  \n
+             - Units: Milliseconds
+    */
+
+  float timeBiasUnc;
+  /**<   System 1 to System 2 time bias uncertainty.  \n
+             - Units: Milliseconds
+    */
+}qmiLocInterSystemBiasStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  qmiLocSvSystemEnumT_v02 system;
+  /**<   Specifies the satellite system constellation.
+
+ Valid values: \n
+      - eQMI_LOC_SV_SYSTEM_GPS (1) --  GPS satellite
+      - eQMI_LOC_SV_SYSTEM_GALILEO (2) --  GALILEO satellite
+      - eQMI_LOC_SV_SYSTEM_SBAS (3) --  SBAS satellite
+      - eQMI_LOC_SV_SYSTEM_COMPASS (4) --  COMPASS satellite (Deprecated)
+      - eQMI_LOC_SV_SYSTEM_GLONASS (5) --  GLONASS satellite
+      - eQMI_LOC_SV_SYSTEM_BDS (6) --  BDS satellite
+      - eQMI_LOC_SV_SYSTEM_QZSS (7) --  QZSS satellite
+ */
+
+  uint16_t systemWeek;
+  /**<   Current system week. \n
+      - For GPS: Calculated from midnight, Jan. 6, 1980 \n
+      - For BDS: Calculated from 00:00:00 on January 1, 2006 of Coordinated Universal Time (UTC) \n
+      - For GAL: Calculated from 00:00 UT on Sunday August 22, 1999 (midnight between August 21 and August 22) \n
+      If the week is unknown, set this value to 65535. \n
+       - Units: Weeks */
+
+  uint32_t systemMsec;
+  /**<   Amount of time into the current week. \n
+       - Units: Milliseconds */
+
+  float systemClkTimeBias;
+  /**<   System clock time bias (submilliseconds). \n
+            - Units: Milliseconds
+        (system time = systemMsec - systemClkTimeBias)
+    */
+
+  float systemClkTimeUncMs;
+  /**<   Single-sided maximum time bias uncertainty. \n
+                - Units: Milliseconds
+    */
+}qmiLocGnssTimeStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint8_t gloFourYear;
+  /**<   GLONASS four year number from 1996. Refer to GLONASS ICD. \n
+        Applicable only for GLONASS and is to be ignored for other constellations. \n
+        If unknown, set this value to 255.
+    */
+
+  uint16_t gloDays;
+  /**<   GLONASS day number in four years. Refer to GLONASS ICD. \n
+        Applicable only for GLONASS and is to be ignored for other constellations. \n
+        If unknown, set this value to 65535.
+    */
+
+  uint32_t gloMsec;
+  /**<   GLONASS time of day in msec. Refer to GLONASS ICD.    \n
+        - Units: Milliseconds
+    */
+
+  float gloClkTimeBias;
+  /**<   System clock time bias (submillisecond). \n
+            - Units: Milliseconds
+        (system time = systemMsec - systemClkTimeBias)
+    */
+
+  float gloClkTimeUncMs;
+  /**<   Single-sided maximum time bias uncertainty. \n
+                - Units: Milliseconds
+    */
+}qmiLocGloTimeStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint32_t refFCount;
+  /**<   Receiver frame counter value at a reference tick. */
+
+  uint8_t systemRtc_valid;
+  /**<   Validity indicator for the system RTC. */
+
+  uint64_t systemRtcMs;
+  /**<   Platform system RTC value. \n
+        - Units: Milliseconds
+    */
+
+  qmiLocTimeSourceEnumT_v02 sourceOfTime;
+  /**<   Source of the time information.
+
+ Valid values: \n
+      - eQMI_LOC_TIME_SRC_INVALID (0) --  Invalid time.
+      - eQMI_LOC_TIME_SRC_NETWORK_TIME_TRANSFER (1) --  Time is set by the 1X system
+      - eQMI_LOC_TIME_SRC_NETWORK_TIME_TAGGING (2) --  Time is set by WCDMA/GSM time tagging (that is,
+       associating network time with GPS time)
+      - eQMI_LOC_TIME_SRC_EXTERNAL_INPUT (3) --  Time is set by an external injection
+      - eQMI_LOC_TIME_SRC_TOW_DECODE (4) --  Time is set after decoding over-the-air GPS navigation data
+       from one GPS satellite
+      - eQMI_LOC_TIME_SRC_TOW_CONFIRMED (5) --  Time is set after decoding over-the-air GPS navigation data
+       from multiple satellites
+      - eQMI_LOC_TIME_SRC_TOW_AND_WEEK_CONFIRMED (6) --  Both time of the week and the GPS week number are known
+      - eQMI_LOC_TIME_SRC_NAV_SOLUTION (7) --  Time is set by the position engine after the fix is obtained
+      - eQMI_LOC_TIME_SRC_SOLVE_FOR_TIME (8) --  Time is set by the position engine after performing SFT;
+       this is done when the clock time uncertainty is large
+      - eQMI_LOC_TIME_SRC_GLO_TOW_DECODE (9) --  Time is set after decoding GLO satellites
+      - eQMI_LOC_TIME_SRC_TIME_TRANSFORM (10) --  Time is set after transforming the GPS to GLO time
+      - eQMI_LOC_TIME_SRC_WCDMA_SLEEP_TIME_TAGGING (11) --  Time is set by the sleep time tag provided by the WCDMA network
+      - eQMI_LOC_TIME_SRC_GSM_SLEEP_TIME_TAGGING (12) --  Time is set by the sleep time tag provided by the GSM network
+      - eQMI_LOC_TIME_SRC_UNKNOWN (13) --  Source of the time is unknown
+      - eQMI_LOC_TIME_SRC_SYSTEM_TIMETICK (14) --  Time is derived from the system clock (better known as the slow clock);
+       GNSS time is maintained irrespective of the GNSS receiver state
+      - eQMI_LOC_TIME_SRC_QZSS_TOW_DECODE (15) --  Time is set after decoding QZSS satellites
+      - eQMI_LOC_TIME_SRC_BDS_TOW_DECODE (16) --  Time is set after decoding BDS satellites
+      - eQMI_LOC_TIME_SRC_GAL_TOW_DECODE (17) --  Time is set after decoding GAL satellites
+ */
+}qmiLocGnssTimeExtStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+typedef uint64_t qmiLocSvMeasStatusValidMaskT_v02;
+#define QMI_LOC_MASK_MEAS_STATUS_SM_STAT_BIT_VALID_V02 ((qmiLocSvMeasStatusValidMaskT_v02)0x00000001ull) /**<  Satellite time in submilliseconds (code-phase)  */
+#define QMI_LOC_MASK_MEAS_STATUS_SB_STAT_BIT_VALID_V02 ((qmiLocSvMeasStatusValidMaskT_v02)0x00000002ull) /**<  Satellite sub-bit time  */
+#define QMI_LOC_MASK_MEAS_STATUS_MS_STAT_BIT_VALID_V02 ((qmiLocSvMeasStatusValidMaskT_v02)0x00000004ull) /**<  Satellite time in milliseconds  */
+#define QMI_LOC_MASK_MEAS_STATUS_BE_CONFIRM_STAT_BIT_VALID_V02 ((qmiLocSvMeasStatusValidMaskT_v02)0x00000008ull) /**<  Signal bit edge is confirmed  */
+#define QMI_LOC_MASK_MEAS_STATUS_VEL_STAT_BIT_VALID_V02 ((qmiLocSvMeasStatusValidMaskT_v02)0x00000010ull) /**<  Satellite Doppler is measured  */
+#define QMI_LOC_MASK_MEAS_STATUS_VEL_FINE_STAT_BIT_VALID_V02 ((qmiLocSvMeasStatusValidMaskT_v02)0x00000020ull) /**<  Fine/coarse Doppler measurement indicator  */
+#define QMI_LOC_MASK_MEAS_STATUS_FROM_RNG_DIFF_STAT_BIT_VALID_V02 ((qmiLocSvMeasStatusValidMaskT_v02)0x00000200ull) /**<  Range update from satellite differences  */
+#define QMI_LOC_MASK_MEAS_STATUS_FROM_VE_DIFF_STAT_BIT_VALID_V02 ((qmiLocSvMeasStatusValidMaskT_v02)0x00000400ull) /**<  Doppler update from satellite differences  */
+typedef uint64_t qmiLocSvMeasStatusMaskT_v02;
+#define QMI_LOC_MASK_MEAS_STATUS_SM_VALID_V02 ((qmiLocSvMeasStatusMaskT_v02)0x00000001ull) /**<  Satellite time in submilliseconds (code phase) is known  */
+#define QMI_LOC_MASK_MEAS_STATUS_SB_VALID_V02 ((qmiLocSvMeasStatusMaskT_v02)0x00000002ull) /**<  Satellite sub-bit time is known  */
+#define QMI_LOC_MASK_MEAS_STATUS_MS_VALID_V02 ((qmiLocSvMeasStatusMaskT_v02)0x00000004ull) /**<  Satellite time in milliseconds is known  */
+#define QMI_LOC_MASK_MEAS_STATUS_BE_CONFIRM_V02 ((qmiLocSvMeasStatusMaskT_v02)0x00000008ull) /**<  Signal bit edge is confirmed   */
+#define QMI_LOC_MASK_MEAS_STATUS_VELOCITY_VALID_V02 ((qmiLocSvMeasStatusMaskT_v02)0x00000010ull) /**<  Satellite Doppler is measured  */
+#define QMI_LOC_MASK_MEAS_STATUS_VELOCITY_FINE_V02 ((qmiLocSvMeasStatusMaskT_v02)0x00000020ull) /**<  TRUE: Fine Doppler is measured, FALSE: Coarse Doppler is measured  */
+#define QMI_LOC_MASK_MEAS_STATUS_FROM_RNG_DIFF_V02 ((qmiLocSvMeasStatusMaskT_v02)0x00000200ull) /**<  Range update from satellite differences is measured  */
+#define QMI_LOC_MASK_MEAS_STATUS_FROM_VE_DIFF_V02 ((qmiLocSvMeasStatusMaskT_v02)0x00000400ull) /**<  Doppler update from satellite differences is measured}  */
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint32_t svTimeMs;
+  /**<       Satellite time in milliseconds. \n
+            - For GPS, BDS, GAL, and QZSS -- Range is 0 thru (604800000-1) \n
+            - For GLONASS -- Range is 0 thru (86400000-1) \n
+            - Units: Milliseconds \vspace{4pt}
+
+            This is valid when the QMI_LOC_MEAS_ STATUS_MS_VALID bit is set
+            in the measurement status. \vspace{4pt}
+
+            @note All SV times in the current measurement block are
+            already propagated to a common reference time epoch.
+    */
+
+  float svTimeSubMs;
+  /**<       Satellite time in submilliseconds. \n
+            Total SV Time = svMs + svSubMs \n
+                - Units: Milliseconds
+    */
+
+  float svTimeUncMs;
+  /**<    Satellite time uncertainty. \n
+                - Units: Milliseconds
+    */
+
+  float dopplerShift;
+  /**<   Satellite Doppler. \n
+             - Units: Meters per second
+    */
+
+  float dopplerShiftUnc;
+  /**<   Satellite Doppler uncertainty. \n
+             - Units: Meters per second
+    */
+
+  uint8_t dopplerAccel_valid;
+  /**<   Validity for Doppler acceleration. */
+
+  float dopplerAccel;
+  /**<   Satellite Doppler acceleration. \n
+             - Units: Hz/second
+    */
+}qmiLocSVTimeSpeedStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+typedef uint16_t qmiLocMeasFieldsValidMaskT_v02;
+#define QMI_LOC_SV_HEALTH_VALID_V02 ((qmiLocMeasFieldsValidMaskT_v02)0x01) /**<  SV health information is valid  */
+#define QMI_LOC_SV_MULTIPATH_EST_VALID_V02 ((qmiLocMeasFieldsValidMaskT_v02)0x02) /**<  Multipath estimate for SV is valid  */
+#define QMI_LOC_SV_FINE_SPEED_VALID_V02 ((qmiLocMeasFieldsValidMaskT_v02)0x04) /**<  Fine speed for SV is valid  */
+#define QMI_LOC_SV_FINE_SPEED_UNC_VALID_V02 ((qmiLocMeasFieldsValidMaskT_v02)0x08) /**<  Fine speed uncertainty for SV is valid  */
+#define QMI_LOC_SV_CARRIER_PHASE_VALID_V02 ((qmiLocMeasFieldsValidMaskT_v02)0x10) /**<  Carrier phase for SV is valid  */
+#define QMI_LOC_SV_SV_DIRECTION_VALID_V02 ((qmiLocMeasFieldsValidMaskT_v02)0x20) /**<  SV direction information for SV is valid  */
+#define QMI_LOC_SV_CYCLESLIP_COUNT_VALID_V02 ((qmiLocMeasFieldsValidMaskT_v02)0x40) /**<  Cycle slip count information is valid  */
+#define QMI_LOC_SV_LOSSOFLOCK_VALID_V02 ((qmiLocMeasFieldsValidMaskT_v02)0x80) /**<  Loss of lock information is valid  */
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint16_t gnssSvId;
+  /**<   GNSS SV ID.
+       \begin{itemize1}
+       \item    Range: \begin{itemize1}
+         \item    For GPS:     1 to 32
+         \item    For GLONASS: 65 to 96. When slot-number to SV ID mapping is unknown, set as 255.
+         \item    For QZSS:    193 to 197
+         \item    For BDS:     201 to 237
+         \item    For GAL:     301 to 336
+         \vspace{-0.18in} \end{itemize1} \end{itemize1} */
+
+  uint8_t gloFrequency;
+  /**<   GLONASS frequency number + 7. \n
+         Valid only for a GLONASS system and
+         is to be ignored for all other systems. \n
+             - Range: 1 to 14
+    */
+
+  qmiLocSvStatusEnumT_v02 svStatus;
+  /**<   Satellite search state.
+
+ Valid values: \n
+      - eQMI_LOC_SV_STATUS_IDLE (1) --  SV is not being actively processed
+      - eQMI_LOC_SV_STATUS_SEARCH (2) --  The system is searching for this SV
+      - eQMI_LOC_SV_STATUS_TRACK (3) --  SV is being tracked
+ */
+
+  qmiLocMeasFieldsValidMaskT_v02 validMask;
+  /**<   Validity mask (0 = Not valid; 1 = Valid). \n
+
+      - QMI_LOC_SV_HEALTH_VALID (0x01) --  SV health information is valid
+      - QMI_LOC_SV_MULTIPATH_EST_VALID (0x02) --  Multipath estimate for SV is valid
+      - QMI_LOC_SV_FINE_SPEED_VALID (0x04) --  Fine speed for SV is valid
+      - QMI_LOC_SV_FINE_SPEED_UNC_VALID (0x08) --  Fine speed uncertainty for SV is valid
+      - QMI_LOC_SV_CARRIER_PHASE_VALID (0x10) --  Carrier phase for SV is valid
+      - QMI_LOC_SV_SV_DIRECTION_VALID (0x20) --  SV direction information for SV is valid
+      - QMI_LOC_SV_CYCLESLIP_COUNT_VALID (0x40) --  Cycle slip count information is valid
+      - QMI_LOC_SV_LOSSOFLOCK_VALID (0x80) --  Loss of lock information is valid
+ */
+
+  uint8_t healthStatus;
+  /**<   Health status. \n
+         \begin{itemize1}
+         - Range: 0 to 1, where  0 = unhealthy, 1 = healthy
+    */
+
+  qmiLocSvInfoMaskT_v02 svInfoMask;
+  /**<   Indicates whether almanac and ephemeris information is available.
+
+ Valid values: \n
+      - QMI_LOC_SVINFO_MASK_HAS_EPHEMERIS (0x01) --  Ephemeris is available for this SV
+      - QMI_LOC_SVINFO_MASK_HAS_ALMANAC (0x02) --  Almanac is available for this SV
+ */
+
+  qmiLocSvMeasStatusValidMaskT_v02 validMeasStatusMask;
+  /**<   Validity mask for measurement status information. \n
+ A set bit in validMeasStatusMask indicates that the corresponding bit
+ in measurementStatus has valid status information: \n
+ Valid masks: \n
+      - QMI_LOC_MASK_MEAS_STATUS_SM_STAT_BIT_VALID (0x00000001) --  Satellite time in submilliseconds (code-phase)
+      - QMI_LOC_MASK_MEAS_STATUS_SB_STAT_BIT_VALID (0x00000002) --  Satellite sub-bit time
+      - QMI_LOC_MASK_MEAS_STATUS_MS_STAT_BIT_VALID (0x00000004) --  Satellite time in milliseconds
+      - QMI_LOC_MASK_MEAS_STATUS_BE_CONFIRM_STAT_BIT_VALID (0x00000008) --  Signal bit edge is confirmed
+      - QMI_LOC_MASK_MEAS_STATUS_VEL_STAT_BIT_VALID (0x00000010) --  Satellite Doppler is measured
+      - QMI_LOC_MASK_MEAS_STATUS_VEL_FINE_STAT_BIT_VALID (0x00000020) --  Fine/coarse Doppler measurement indicator
+      - QMI_LOC_MASK_MEAS_STATUS_FROM_RNG_DIFF_STAT_BIT_VALID (0x00000200) --  Range update from satellite differences
+      - QMI_LOC_MASK_MEAS_STATUS_FROM_VE_DIFF_STAT_BIT_VALID (0x00000400) --  Doppler update from satellite differences
+\vspace{4pt}
+ Additionally, MSB 0xFFC0000000000000 bits indicate the validity of DONT_USE bits. \n
+
+ */
+
+  qmiLocSvMeasStatusMaskT_v02 measurementStatus;
+  /**<   Bitmask indicating the SV measurement status.
+
+ Valid bitmasks: \n
+      - QMI_LOC_MASK_MEAS_STATUS_SM_VALID (0x00000001) --  Satellite time in submilliseconds (code phase) is known
+      - QMI_LOC_MASK_MEAS_STATUS_SB_VALID (0x00000002) --  Satellite sub-bit time is known
+      - QMI_LOC_MASK_MEAS_STATUS_MS_VALID (0x00000004) --  Satellite time in milliseconds is known
+      - QMI_LOC_MASK_MEAS_STATUS_BE_CONFIRM (0x00000008) --  Signal bit edge is confirmed
+      - QMI_LOC_MASK_MEAS_STATUS_VELOCITY_VALID (0x00000010) --  Satellite Doppler is measured
+      - QMI_LOC_MASK_MEAS_STATUS_VELOCITY_FINE (0x00000020) --  TRUE: Fine Doppler is measured, FALSE: Coarse Doppler is measured
+      - QMI_LOC_MASK_MEAS_STATUS_FROM_RNG_DIFF (0x00000200) --  Range update from satellite differences is measured
+      - QMI_LOC_MASK_MEAS_STATUS_FROM_VE_DIFF (0x00000400) --  Doppler update from satellite differences is measured}
+
+ If any MSB bit in 0xFFC0000000000000 DONT_USE is set, the measurement
+ must not be used by the client.
+ */
+
+  uint16_t CNo;
+  /**<   Carrier to noise ratio.  \n
+             - Units: dBHz \n
+             - Scale: 0.1
+    */
+
+  uint16_t gloRfLoss;
+  /**<   GLONASS RF loss reference to the antenna. \n
+                 - Units: dB \n
+                 - Scale: 0.1
+    */
+
+  int32_t measLatency;
+  /**<   Age of the measurement. A positive value means the measurement precedes the reference time. \n
+                 - Units: Milliseconds
+    */
+
+  qmiLocSVTimeSpeedStructT_v02 svTimeSpeed;
+  /**<   SV time and speed information. */
+
+  uint8_t lossOfLock;
+  /**<   Loss of signal lock indicator.  \n
+             - 0: Signal is in continuous track \n
+             - 1: Signal is not in track
+    */
+
+  float multipathEstimate;
+  /**<   Estimate of multipath in a measurement. \n
+             - Units: Meters
+    */
+
+  float fineSpeed;
+  /**<   Carrier phase derived speed. \n
+             - Units: Meters per second
+    */
+
+  float fineSpeedUnc;
+  /**<   Carrier phase derived speed uncertainty. \n
+             - Units: Meters per second
+    */
+
+  double carrierPhase;
+  /**<   Carrier phase measurement (L1 cycles).
+    */
+
+  uint8_t cycleSlipCount;
+  /**<   Increments when a cycle slip is detected. */
+
+  float svAzimuth;
+  /**<   Satellite azimuth. \n
+                - Units: Radians \n
+                - Range: 0 to 2*pi()
+    */
+
+  float svElevation;
+  /**<   Satellite elevation. \n
+                - Units: Radians \n
+                - Range: 0 to pi()/2
+    */
+}qmiLocSVMeasurementStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Sends a satellite measurement report to the control point. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Current Message Sequence Number  */
+  uint8_t seqNum;
+  /**<   Current message number. Used for segmentation/assembly of measurement reports. */
+
+  /* Mandatory */
+  /*  Maximum Number of Messages to be Sent for Present Time Epoch */
+  uint8_t maxMessageNum;
+  /**<   Maximum number of messages that are to be sent for the present time epoch. */
+
+  /* Mandatory */
+  /*   Specifies Satellite System Constellation of This Report */
+  qmiLocSvSystemEnumT_v02 system;
+  /**<   Specifies the satellite system constellation of this report.
+
+ Valid values: \n
+      - eQMI_LOC_SV_SYSTEM_GPS (1) --  GPS satellite
+      - eQMI_LOC_SV_SYSTEM_GALILEO (2) --  GALILEO satellite
+      - eQMI_LOC_SV_SYSTEM_SBAS (3) --  SBAS satellite
+      - eQMI_LOC_SV_SYSTEM_COMPASS (4) --  COMPASS satellite (Deprecated)
+      - eQMI_LOC_SV_SYSTEM_GLONASS (5) --  GLONASS satellite
+      - eQMI_LOC_SV_SYSTEM_BDS (6) --  BDS satellite
+      - eQMI_LOC_SV_SYSTEM_QZSS (7) --  QZSS satellite
+ */
+
+  /* Optional */
+  /*  GNSS Receiver Clock Frequency Information */
+  uint8_t rcvrClockFrequencyInfo_valid;  /**< Must be set to true if rcvrClockFrequencyInfo is being passed */
+  qmiLocRcvrClockFrequencyInfoStructT_v02 rcvrClockFrequencyInfo;
+
+  /* Optional */
+  /*  Leap Second Information */
+  uint8_t leapSecondInfo_valid;  /**< Must be set to true if leapSecondInfo is being passed */
+  qmiLocLeapSecondInfoStructT_v02 leapSecondInfo;
+
+  /* Optional */
+  /*  GPS to GLONASS Intersystem Time Bias */
+  uint8_t gpsGloInterSystemBias_valid;  /**< Must be set to true if gpsGloInterSystemBias is being passed */
+  qmiLocInterSystemBiasStructT_v02 gpsGloInterSystemBias;
+  /**<   \vspace{4pt} \n
+       This is reported if both GPS and GLONASS system
+       information reporting are enabled. \n
+       - System 1: GPS \n
+       - System 2: GLONASS
+  */
+
+  /* Optional */
+  /*  GPS to BDS Intersystem Time Bias */
+  uint8_t gpsBdsInterSystemBias_valid;  /**< Must be set to true if gpsBdsInterSystemBias is being passed */
+  qmiLocInterSystemBiasStructT_v02 gpsBdsInterSystemBias;
+  /**<   \vspace{4pt} \n
+       This is reported if both GPS and BDS system
+       information reporting are enabled. \n
+       - System 1: GPS \n
+       - System 2: BDS
+  */
+
+  /* Optional */
+  /*  GPS to GALILEO Intersystem Time Bias */
+  uint8_t gpsGalInterSystemBias_valid;  /**< Must be set to true if gpsGalInterSystemBias is being passed */
+  qmiLocInterSystemBiasStructT_v02 gpsGalInterSystemBias;
+  /**<   \vspace{4pt} \n
+       This is reported if both GPS and GALILEO system
+       information reporting are enabled. \n
+       - System 1: GPS \n
+       - System 2: GALILEO
+  */
+
+  /* Optional */
+  /*  BDS to GLONASS Intersystem Time Bias */
+  uint8_t bdsGloInterSystemBias_valid;  /**< Must be set to true if bdsGloInterSystemBias is being passed */
+  qmiLocInterSystemBiasStructT_v02 bdsGloInterSystemBias;
+  /**<   \vspace{4pt} \n
+       This is reported if both BDS and GLONASS system
+       information reporting are enabled. \n
+       - System 1: BDS \n
+       - System 2: GLONASS
+  */
+
+  /* Optional */
+  /*  GAL to GLONASS Intersystem Time Bias */
+  uint8_t galGloInterSystemBias_valid;  /**< Must be set to true if galGloInterSystemBias is being passed */
+  qmiLocInterSystemBiasStructT_v02 galGloInterSystemBias;
+  /**<   \vspace{4pt} \n
+       This is reported if both GAL and GLONASS system
+       information reporting are enabled. \n
+       - System 1: GAL \n
+       - System 2: GLONASS
+  */
+
+  /* Optional */
+  /*  GAL to BDS Intersystem Time Bias */
+  uint8_t galBdsInterSystemBias_valid;  /**< Must be set to true if galBdsInterSystemBias is being passed */
+  qmiLocInterSystemBiasStructT_v02 galBdsInterSystemBias;
+  /**<   \vspace{4pt} \n
+       This is reported if both GAL and BDS system
+       information reporting are enabled. \n
+       - System 1: GAL \n
+       - System 2: BDS
+  */
+
+  /* Optional */
+  /*  Satellite System Time Information for GPS, BDS, GAL Constellation */
+  uint8_t systemTime_valid;  /**< Must be set to true if systemTime is being passed */
+  qmiLocGnssTimeStructT_v02 systemTime;
+
+  /* Optional */
+  /*  GLONASS System Time Information */
+  uint8_t gloTime_valid;  /**< Must be set to true if gloTime is being passed */
+  qmiLocGloTimeStructT_v02 gloTime;
+
+  /* Optional */
+  /*  Extended Time Information */
+  uint8_t systemTimeExt_valid;  /**< Must be set to true if systemTimeExt is being passed */
+  qmiLocGnssTimeExtStructT_v02 systemTimeExt;
+
+  /* Optional */
+  /*  Satellite System Measurement Report for Enabled Constellation */
+  uint8_t svMeasurement_valid;  /**< Must be set to true if svMeasurement is being passed */
+  uint32_t svMeasurement_len;  /**< Must be set to # of elements in svMeasurement */
+  qmiLocSVMeasurementStructT_v02 svMeasurement[QMI_LOC_SV_MEAS_LIST_MAX_SIZE_V02];
+
+  /* Optional */
+  /*  Extended Time Information - Cumulative number of clock resets */
+  uint8_t numClockResets_valid;  /**< Must be set to true if numClockResets is being passed */
+  uint32_t numClockResets;
+  /**<   Number of clock reset/discontinuities detected, affecting local HW counter value */
+}qmiLocEventGnssSvMeasInfoIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+typedef uint16_t qmiLocSvPolyStatusMaskT_v02;
+#define QMI_LOC_SV_POLY_SRC_ALM_CORR_V02 ((qmiLocSvPolyStatusMaskT_v02)0x01) /**<  Polynomials based on XTRA  */
+#define QMI_LOC_SV_POLY_GLO_STR4_V02 ((qmiLocSvPolyStatusMaskT_v02)0x02) /**<  GLONASS string 4 has been received  */
+typedef uint16_t qmiLocSvPolyStatusMaskValidityT_v02;
+#define QMI_LOC_SV_POLY_SRC_ALM_CORR_VALID_V02 ((qmiLocSvPolyStatusMaskValidityT_v02)0x01) /**<  Validity status for QMI_LOC_SV_POLY_SRC_ALM_CORR  */
+#define QMI_LOC_SV_POLY_GLO_STR4_VALID_V02 ((qmiLocSvPolyStatusMaskValidityT_v02)0x02) /**<  Validity status for QMI_LOC_SV_POLY_GLO_STR4   */
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Sends a satellite polynomial report to the control point. */
+typedef struct {
+
+  /* Mandatory */
+  /*  GNSS SV Polynomial Report */
+  uint16_t gnssSvId;
+  /**<   GNSS SV ID. \begin{itemize1}
+       \item    Range:    \begin{itemize1}
+         \item    For GPS:     1 to 32
+         \item    For GLONASS: 65 to 96 (when the slot number to SV ID mapping is unknown, set to 255)
+         \item    For SBAS:    120 to 158 and 183 to 187
+         \item    For QZSS:    193 to 197
+         \item    For BDS:     201 to 237
+         \item    For GAL:     301 to 336
+       \vspace{-0.18in} \end{itemize1} \end{itemize1} */
+
+  /* Mandatory */
+  /*  Reference Time for Polynomial Calculations */
+  double T0;
+  /**<    Reference time for polynomial calculations. \n
+           - GPS, QZSS: Seconds in the week \n
+           - GLO: Full seconds since Jan. 1, 1996 \n
+           - BDS: Full seconds since Jan. 1, 2006 \n
+           - GAL: Calculated from 00:00 UT on Sunday, August 22, 1999 (midnight between August 21 and August 22)
+    */
+
+  /* Mandatory */
+  /*  SV Polynomial Validity Status */
+  qmiLocSvPolyStatusMaskValidityT_v02 svPolyFlagValid;
+  /**<   Validity mask for bits in svPolyFlags. A set bit in svPolyFlagValid indicates that a
+ corresponding bit in svPolyFlags has valid status information.
+
+ Valid bitmasks: \n
+      - QMI_LOC_SV_POLY_SRC_ALM_CORR_VALID (0x01) --  Validity status for QMI_LOC_SV_POLY_SRC_ALM_CORR
+      - QMI_LOC_SV_POLY_GLO_STR4_VALID (0x02) --  Validity status for QMI_LOC_SV_POLY_GLO_STR4   */
+
+  /* Mandatory */
+  /*  SV Polynomial Report Status */
+  qmiLocSvPolyStatusMaskT_v02 svPolyFlags;
+  /**<   Flags indicating the status of a polynomial report.
+
+ Valid bitmasks: \n
+      - QMI_LOC_SV_POLY_SRC_ALM_CORR (0x01) --  Polynomials based on XTRA
+      - QMI_LOC_SV_POLY_GLO_STR4 (0x02) --  GLONASS string 4 has been received  */
+
+  /* Optional */
+  /*  Polynomial Coefficient's 0th Term for X, Y, and Z Coordinates */
+  uint8_t polyCoeffXYZ0_valid;  /**< Must be set to true if polyCoeffXYZ0 is being passed */
+  double polyCoeffXYZ0[QMI_LOC_SV_POLY_XYZ_0_TH_ORDER_COEFF_SIZE_V02];
+  /**<   Polynomial coefficient's 0th term for X, Y, and Z coordinates (C0X, C0Y, C0Z). \n
+             - Units: Meters
+    */
+
+  /* Optional */
+  /*  Polynomial Coefficient's 1st, 2nd, and 3rd Terms for X, Y, and Z Coordinates */
+  uint8_t polyCoefXYZN_valid;  /**< Must be set to true if polyCoefXYZN is being passed */
+  double polyCoefXYZN[QMI_LOC_SV_POLY_XYZ_N_TH_ORDER_COEFF_SIZE_V02];
+  /**<    Polynomial coefficient's 1st, 2nd, and 3rd terms for X, Y, and Z coordinates (C1X, C2X,... C2Z, C3Z). \begin{itemize1}
+          \item Units: \begin{itemize1}
+             \item 1st term -- Meters/second
+             \item 2nd term -- Meters/second^2
+             \item 3rd term -- Meters/seconds^3 \vspace{-0.18in} \end{itemize1} end{itemize1}
+    */
+
+  /* Optional */
+  /*  Polynomial Coefficients for Satellite Clock Bias Correction */
+  uint8_t polyCoefClockBias_valid;  /**< Must be set to true if polyCoefClockBias is being passed */
+  float polyCoefClockBias[QMI_LOC_SV_POLY_SV_CLKBIAS_COEFF_SIZE_V02];
+  /**<    Polynomial coefficients for satellite clock bias correction (C0T, C1T, C2T, C3T). \begin{itemize1}
+          \item Units: \begin{itemize1}
+             \item 0th term -- Milliseconds/second
+             \item 1st term -- Milliseconds/second^2
+             \item 2nd term -- Milliseconds/second^3
+             \item 3rd term -- Milliseconds/second^4 \vspace{-0.18in} \end{itemize1} end{itemize1}
+    */
+
+  /* Optional */
+  /*  GLONASS Frequency Number */
+  uint8_t gloFrequency_valid;  /**< Must be set to true if gloFrequency is being passed */
+  uint8_t gloFrequency;
+  /**<   GLONASS frequency number + 7. \n
+         Valid only for GLONASS systems and
+         must be ignored for all other systems. \n
+             - Range: 1 to 14
+    */
+
+  /* Optional */
+  /*  Ephemeris Reference Time */
+  uint8_t IODE_valid;  /**< Must be set to true if IODE is being passed */
+  uint16_t IODE;
+  /**<   Ephemeris reference time. \n
+         - GPS -- Issue of data ephemeris used (unitless) \n
+         - GLONASS -- Tb 7-bit \n
+         - Galileo -- 10-bit
+    */
+
+  /* Optional */
+  /*  Enhanced Reference Time */
+  uint8_t enhancedIOD_valid;  /**< Must be set to true if enhancedIOD is being passed */
+  uint32_t enhancedIOD;
+  /**<   For BDS ephemeris, this is TOE.
+    */
+
+  /* Optional */
+  /*  SV Position Uncertainty */
+  uint8_t svPosUnc_valid;  /**< Must be set to true if svPosUnc is being passed */
+  float svPosUnc;
+  /**<    SV position uncertainty. \n
+             - Units: Meters
+    */
+
+  /* Optional */
+  /*  Iono Delay */
+  uint8_t ionoDelay_valid;  /**< Must be set to true if ionoDelay is being passed */
+  float ionoDelay;
+  /**<   Ionospheric delay at T0. \n
+             - Units: Meters
+    */
+
+  /* Optional */
+  /*  Iono Delay Rate */
+  uint8_t ionoDot_valid;  /**< Must be set to true if ionoDot is being passed */
+  float ionoDot;
+  /**<   Ionospheric delay rate. \n
+             - Units: Meters/second
+    */
+
+  /* Optional */
+  /*  SBAS Iono Delay */
+  uint8_t sbasIonoDelay_valid;  /**< Must be set to true if sbasIonoDelay is being passed */
+  float sbasIonoDelay;
+  /**<   SBAS ionospheric delay at T0. \n
+             - Units: Meters
+    */
+
+  /* Optional */
+  /*  SBAS Iono Delay Rate */
+  uint8_t sbasIonoDot_valid;  /**< Must be set to true if sbasIonoDot is being passed */
+  float sbasIonoDot;
+  /**<   SBAS ionospheric delay rate. \n
+             - Units: Meters/second
+    */
+
+  /* Optional */
+  /*  Tropospheric Delay */
+  uint8_t tropoDelay_valid;  /**< Must be set to true if tropoDelay is being passed */
+  float tropoDelay;
+  /**<   Tropospheric delay. \n
+             - Units: Meters
+    */
+
+  /* Optional */
+  /*  Satellite Elevation */
+  uint8_t elevation_valid;  /**< Must be set to true if elevation is being passed */
+  float elevation;
+  /**<   Satellite elevation at T0. \n
+             - Units: Radians
+    */
+
+  /* Optional */
+  /*  Satellite Elevation Rate */
+  uint8_t elevationDot_valid;  /**< Must be set to true if elevationDot is being passed */
+  float elevationDot;
+  /**<   Satellite elevation rate. \n
+             - Units: Radians/second
+    */
+
+  /* Optional */
+  /*  Satellite Elevation Uncertainty */
+  uint8_t elenationUnc_valid;  /**< Must be set to true if elenationUnc is being passed */
+  float elenationUnc;
+  /**<   SV elevation uncertainty. \n
+             - Units: Radians
+    */
+
+  /* Optional */
+  /*  Polynomial Coefficients for SV Velocity */
+  uint8_t velCoef_valid;  /**< Must be set to true if velCoef is being passed */
+  double velCoef[QMI_LOC_SV_POLY_VELOCITY_COEF_SIZE_V02];
+  /**<   Polynomial coefficients for SV velocity (C0X, C1X, C2X, C3X,... C2Z, C3Z). \begin{itemize1}
+         \item Units: \begin{itemize1}
+            \item 0th term -- Meters/second
+            \item 1st term -- Meters/second^2
+            \item 2nd term -- Meters/second^3
+            \item 3rd term -- Meters/second^4 \vspace{-0.18in} \end{itemize1} end{itemize1}
+    */
+}qmiLocEventGnssSvPolyIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint8_t wifiApMacAddress[QMI_LOC_WIFI_MAC_ADDR_LENGTH_V02];
+  /**<   MAC address of the Wi-Fi AP. */
+}qmiLocWifiApMacAddressStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  char uuid[QMI_LOC_MAX_IBEACON_UUID_STR_LENGTH_V02 + 1];
+  /**<   NULL-terminated IBeacon identifier string; a 128-bit value. */
+
+  uint32_t majorNumber;
+  /**<   IBeacon major number.*/
+
+  uint32_t minorNumber;
+  /**<   IBeacon minor number.*/
+}qmiLocIBeaconIdStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to inject the Geofence context. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Transaction ID */
+  uint32_t transactionId;
+  /**<   Identifies the transaction. The transaction ID
+       is returned in the Add Geofence Context indication. */
+
+  /* Optional */
+  /*  Geofence ID */
+  uint8_t geofenceId_valid;  /**< Must be set to true if geofenceId is being passed */
+  uint32_t geofenceId;
+  /**<   Geofence identifier allocated by the engine.    \n
+       If the Geofence ID is not provided, a Geofence is created with an Area ID
+       list only (e.g., Wi-Fi only list Geofence). \n
+       If the Geofence ID is provided, the added list is used as assistance data
+       to the existing Geofence. */
+
+  /* Optional */
+  /*  Wi-Fi AP SSID String */
+  uint8_t wifiApSsidInfo_valid;  /**< Must be set to true if wifiApSsidInfo is being passed */
+  uint32_t wifiApSsidInfo_len;  /**< Must be set to # of elements in wifiApSsidInfo */
+  qmiLocWifiApSsidStructT_v02 wifiApSsidInfo[QMI_LOC_WIFI_AREA_ID_LIST_LENGTH_V02];
+  /**<   \vspace{4pt} \n The ordering of the Wi-Fi AP SSID list should match the Wi-Fi AP MAC address
+       list when both are provided,
+       that is, the first element of the Wi-Fi AP SSID list must be the SSID of the AP whose MAC
+       address is in the first element in the Wi-Fi AP MAC address, etc.  */
+
+  /* Optional */
+  /*  Wi-Fi AP MAC Address List for the Geofence */
+  uint8_t wifiApMacAddressList_valid;  /**< Must be set to true if wifiApMacAddressList is being passed */
+  uint32_t wifiApMacAddressList_len;  /**< Must be set to # of elements in wifiApMacAddressList */
+  qmiLocWifiApMacAddressStructT_v02 wifiApMacAddressList[QMI_LOC_WIFI_AREA_ID_LIST_LENGTH_V02];
+  /**<   The ordering of the Wi-Fi AP SSID list should match the Wi-Fi AP MAC address
+       list when both are provided,
+       that is, the first element of the Wi-Fi AP SSID list must be the SSID of the AP whose MAC
+       address is in the first element in the Wi-Fi AP MAC address, etc.  */
+
+  /* Optional */
+  /*  TDSCDMA Cell ID List for the Geofence */
+  uint8_t tdsCdmaCellIDList_valid;  /**< Must be set to true if tdsCdmaCellIDList is being passed */
+  qmiLocTDSCDMACellIdStructT_v02 tdsCdmaCellIDList[QMI_LOC_CELL_ID_LIST_LENGTH_V02];
+  /**<   \n Identifies the TDSCDMA cell on which the device is currently camped. */
+
+  /* Optional */
+  /*  WCDMA Cell ID List for the Geofence */
+  uint8_t wcdmaCellIDList_valid;  /**< Must be set to true if wcdmaCellIDList is being passed */
+  uint32_t wcdmaCellIDList_len;  /**< Must be set to # of elements in wcdmaCellIDList */
+  qmiLocWCDMACellIdStructT_v02 wcdmaCellIDList[QMI_LOC_CELL_ID_LIST_LENGTH_V02];
+  /**<   \vspace{4pt} \n Identifies the WCDMA cell on which the device is currently camped. */
+
+  /* Optional */
+  /*  GSM Cell ID List for the Geofence */
+  uint8_t gsmCellIDList_valid;  /**< Must be set to true if gsmCellIDList is being passed */
+  uint32_t gsmCellIDList_len;  /**< Must be set to # of elements in gsmCellIDList */
+  qmiLocGSMCellIdStructT_v02 gsmCellIDList[QMI_LOC_CELL_ID_LIST_LENGTH_V02];
+  /**<   \n Identifies the GSM cell on which the device is currently camped. */
+
+  /* Optional */
+  /*  IBeacon List of the Geofence */
+  uint8_t iBeaconList_valid;  /**< Must be set to true if iBeaconList is being passed */
+  uint32_t iBeaconList_len;  /**< Must be set to # of elements in iBeaconList */
+  qmiLocIBeaconIdStructT_v02 iBeaconList[QMI_LOC_IBEACON_LIST_LENGTH_V02];
+}qmiLocAddGeofenceContextReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to inject the Geofence context. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Status of the Add Geofence Context Request */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Add Geofence Context request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Optional */
+  /*  Transaction ID */
+  uint8_t transactionId_valid;  /**< Must be set to true if transactionId is being passed */
+  uint32_t transactionId;
+  /**<   Transaction ID that was specified in the Add Geofence Context
+       request. This parameter is always present
+       if the status field is set to SUCCESS. */
+
+  /* Optional */
+  /*  Geofence ID */
+  uint8_t geofenceId_valid;  /**< Must be set to true if geofenceId is being passed */
+  uint32_t geofenceId;
+  /**<   Geofence identifier allocated by the engine.    \n
+       If the client specifies the Geofence ID during the Add Geofence Context request,
+       the same ID is returned.    \n
+       If the client does not specify the Geofence ID during the Add Geofence Context request,
+       a new Geofence ID is created by the Geofence engine and returned. */
+
+  /* Optional */
+  /*  Context ID */
+  uint8_t contextId_valid;  /**< Must be set to true if contextId is being passed */
+  uint32_t contextId;
+  /**<   Geofence context ID allocated by the engine.
+       The context ID is generated by the Geofence engine to identify the context
+       for a particular Geofence ID.
+       The same Geofence ID may be associated with multiple contexts.  */
+}qmiLocAddGeofenceContextIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to inject the Geofence engine context. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Transaction ID */
+  uint32_t transactionId;
+  /**<   Identifies the transaction. The transaction ID
+       is returned in the Set Geofence Engine Context indication. */
+
+  /* Optional */
+  /*  UTC Timestamp of the Day */
+  uint8_t utcTimeOfDay_valid;  /**< Must be set to true if utcTimeOfDay is being passed */
+  uint64_t utcTimeOfDay;
+  /**<   The UTC time of the day.  */
+
+  /* Optional */
+  /*  Temperature of the Day in Fahrenheit */
+  uint8_t temperature_valid;  /**< Must be set to true if temperature is being passed */
+  int32_t temperature;
+  /**<   The temperature of the day in degrees Fahrenheit.  */
+}qmiLocSetGeofenceEngineContextReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to inject the Geofence engine context. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Status of the Set Geofence Engine Context Request */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Set Geofence Engine Context request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Optional */
+  /*  Transaction ID */
+  uint8_t transactionId_valid;  /**< Must be set to true if transactionId is being passed */
+  uint32_t transactionId;
+  /**<   Transaction ID that was specified in the Set Geofence Engine Context
+       request. This parameter will always be present
+       if the status field is set to SUCCESS. */
+}qmiLocSetGeofenceEngineContextIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to delete the Geofence context. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Transaction ID */
+  uint32_t transactionId;
+  /**<   Identifies the transaction. The transaction ID
+       is returned in the Delete Geofence Context indication. */
+
+  /* Mandatory */
+  /*  Geofence ID */
+  uint32_t geofenceId;
+  /**<   Identifies the Geofence whose context is to be deleted.  */
+
+  /* Optional */
+  /*  Context ID */
+  uint8_t contextId_valid;  /**< Must be set to true if contextId is being passed */
+  uint32_t contextId;
+  /**<   Identifies the context associated with the Geofence to be deleted.
+       If not specified, all contexts associated with this Geofence are deleted. */
+}qmiLocDeleteGeofenceContextReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to delete the Geofence context. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Status of the Delete Geofence Context Request */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Delete Geofence Context request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Optional */
+  /*  Transaction ID */
+  uint8_t transactionId_valid;  /**< Must be set to true if transactionId is being passed */
+  uint32_t transactionId;
+  /**<   Transaction ID that was specified in the Delete Geofence Context request.
+       This parameter will always be present
+       if the status field is set to SUCCESS. */
+
+  /* Optional */
+  /*  Geofence ID */
+  uint8_t geofenceId_valid;  /**< Must be set to true if geofenceId is being passed */
+  uint32_t geofenceId;
+  /**<   Identifier for the Geofence whose context was deleted. */
+
+  /* Optional */
+  /*  Context ID */
+  uint8_t contextId_valid;  /**< Must be set to true if contextId is being passed */
+  uint32_t contextId;
+  /**<   Identifier for the context of the Geofence that was deleted. */
+}qmiLocDeleteGeofenceContextIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Injects Global Terrestrial Positioning (GTP) WWAN client downloaded data. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Data */
+  uint32_t ClientDownloadedData_len;  /**< Must be set to # of elements in ClientDownloadedData */
+  char ClientDownloadedData[QMI_LOC_MAX_GTP_WWAN_CLIENT_DOWNLOADED_DATA_LEN_V02];
+  /**<   WWAN client downloaded data. \n
+         - Type: Array of bytes \n
+         - Maximum length of the array: 512
+    */
+}qmiLocInjectGtpClientDownloadedDataReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Injects Global Terrestrial Positioning (GTP) WWAN client downloaded data. */
+typedef struct {
+
+  /* Mandatory */
+  /*  GTP Client Downloaded Data Injection Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the GTP client downloaded data injection.
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+}qmiLocInjectGtpClientDownloadedDataIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Sends a GDT upload begin response to GDT MP. */
+typedef struct {
+
+  /* Mandatory */
+  /*  GDT Service ID */
+  qmiLocGdtServiceIdEnumT_v02 serviceId;
+  /**<   Values: \n
+      - eQMI_LOC_GDT_SERVICE_WWAN (1) --  GDT service for WWAN UL
+      - eQMI_LOC_GDT_SERVICE_WWAN_DL (2) --  GDT service for WWAN DL  */
+
+  /* Mandatory */
+  /*  Session ID */
+  uint32_t sessionId;
+  /**<   Session ID. */
+
+  /* Mandatory */
+  /*  Access Status to GDT */
+  qmiLocGdtAccessStatusEnumT_v02 gdtAccessStatus;
+  /**<   GDT status information for this service ID.
+
+ Values: \n
+      - eQMI_LOC_GDT_ACCESS_ALLOWED (1) --  GDT access to the service is allowed
+      - eQMI_LOC_GDT_ACCESS_FAILED (2) --  Any type of GDT access error
+      - eQMI_LOC_GDT_ACCESS_NOT_ALLOWED (3) --  GDT access to the service is not allowed
+ */
+}qmiLocGdtUploadBeginStatusReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Sends a GDT upload begin response to GDT MP. */
+typedef struct {
+
+  /* Mandatory */
+  /*  GDT Upload Begin Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the GDT begin request.
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+}qmiLocGdtUploadBeginStatusIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCGDTENDACKENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_GDT_ACK_SUCCESS_V02 = 1, /**<  The sent data is accepeted   */
+  eQMI_LOC_GDT_ACK_FAILED_V02 = 2, /**<  The sent data was not accepted   */
+  eQMI_LOC_GDT_ACK_INVALID_V02 = 3, /**<  General error in the received data  */
+  QMILOCGDTENDACKENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocGdtEndAckEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Sends a GDT upload end response to GDT MP. */
+typedef struct {
+
+  /* Mandatory */
+  /*  GDT Service ID */
+  qmiLocGdtServiceIdEnumT_v02 serviceId;
+  /**<   Values: \n
+
+      - eQMI_LOC_GDT_SERVICE_WWAN (1) --  GDT service for WWAN UL
+      - eQMI_LOC_GDT_SERVICE_WWAN_DL (2) --  GDT service for WWAN DL */
+
+  /* Mandatory */
+  /*  Session ID */
+  uint32_t sessionId;
+  /**<   Session ID. */
+
+  /* Mandatory */
+  /*  Access Status to GDT */
+  qmiLocGdtEndAckEnumT_v02 gdtEndStatus;
+  /**<   GDT end status information for this service ID.
+
+ Valid values: \n
+      - eQMI_LOC_GDT_ACK_SUCCESS (1) --  The sent data is accepeted
+      - eQMI_LOC_GDT_ACK_FAILED (2) --  The sent data was not accepted
+      - eQMI_LOC_GDT_ACK_INVALID (3) --  General error in the received data
+ */
+}qmiLocGdtUploadEndReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Sends a GDT upload end response to GDT MP. */
+typedef struct {
+
+  /* Mandatory */
+  /*  UTC GDT Upload End Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the GDT upload end request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+}qmiLocGdtUploadEndIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCGTPAPSTATUSENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_GTP_AP_STATUS_DB_READY_V02 = 1, /**<  Indicates that the AP is initialized and ready to process MP download requests   */
+  eQMI_LOC_GTP_AP_STATUS_DB_REFRESHED_V02 = 2, /**<  Indicates that the AP has successfully refreshed partitions  */
+  eQMI_LOC_GTP_AP_STATUS_DB_DELETED_V02 = 3, /**<  Indicates that the AP has removed local partitions   */
+  QMILOCGTPAPSTATUSENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocGtpApStatusEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Sends a Global Terrestrial Position (GTP) message to the MP
+                    notifying the GTP MP of AP DB readiness. */
+typedef struct {
+
+  /* Mandatory */
+  /*  AP DB Status */
+  qmiLocGtpApStatusEnumT_v02 gtpApDbStatus;
+  /**<   GTP AP DB status information.
+
+ Valid values: \n
+      - eQMI_LOC_GTP_AP_STATUS_DB_READY (1) --  Indicates that the AP is initialized and ready to process MP download requests
+      - eQMI_LOC_GTP_AP_STATUS_DB_REFRESHED (2) --  Indicates that the AP has successfully refreshed partitions
+      - eQMI_LOC_GTP_AP_STATUS_DB_DELETED (3) --  Indicates that the AP has removed local partitions
+ */
+
+  /* Optional */
+  /*  AP PCID (8 byte) */
+  uint8_t gtpApPcid64_valid;  /**< Must be set to true if gtpApPcid64 is being passed */
+  uint64_t gtpApPcid64;
+  /**<   AP pseudoclient ID. */
+
+  /* Optional */
+  /*  OEM ID (non-NULL Terminated) */
+  uint8_t oemId_valid;  /**< Must be set to true if oemId is being passed */
+  uint32_t oemId_len;  /**< Must be set to # of elements in oemId */
+  char oemId[QMI_LOC_MAX_OEM_ID_LEN_V02];
+  /**<   OEM ID. \n
+         - Type: character string \n
+         - Maximum length of the array: 256
+    */
+
+  /* Optional */
+  /*  Model ID (non-NULL Terminated) */
+  uint8_t modelId_valid;  /**< Must be set to true if modelId is being passed */
+  uint32_t modelId_len;  /**< Must be set to # of elements in modelId */
+  char modelId[QMI_LOC_MAX_MODEL_ID_LEN_V02];
+  /**<   Model ID. \n
+         - Type: character string \n
+         - Maximum length of the array: 256
+    */
+}qmiLocGtpApStatusReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint8_t asnMajorVersion;
+  /**<   ASN major version. */
+
+  uint8_t asnMinorVersion;
+  /**<   ASN minor version. */
+
+  uint8_t asnPointVersion;
+  /**<   ASN point version. */
+}qmiLocGtpAsnVerStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Sends a Global Terrestrial Position (GTP) message to the MP
+                    notifying the GTP MP of AP DB readiness. */
+typedef struct {
+
+  /* Mandatory */
+  /*  GTP MP Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the GTP handshake.
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Mandatory */
+  /*  MP Client Software Version */
+  uint16_t clientSoftwareVersion;
+  /**<   MP client software version. */
+
+  /* Mandatory */
+  /*  MP ASN Version */
+  qmiLocGtpAsnVerStructT_v02 asnVersion;
+}qmiLocGtpApStatusIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCGTPPROCESSSTATUSENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_GTP_PROCESS_SUCCESS_FROM_LOCAL_V02 = 1, /**<  DL processing is processed successfully locally   */
+  eQMI_LOC_GTP_PROCESS_SUCCESS_FROM_SERVER_V02 = 2, /**<  DL processing is processed successfully via server access   */
+  eQMI_LOC_GTP_PROCESS_NOT_ALLOWED_AP_NOT_READY_V02 = 3, /**<  DL processing is not allowed because the AP is not ready   */
+  eQMI_LOC_GTP_PROCESS_NOT_ALLOWED_AP_TIMEOUT_V02 = 4, /**<  DL processing is not allowed because the AP cannot process within the given interval   */
+  eQMI_LOC_GTP_PROCESS_NOT_ALLOWED_NO_CONNECTIVITY_V02 = 5, /**<  DL processing via server is not allowed since AP has no connectivity but
+       will be processed locally   */
+  eQMI_LOC_GTP_PROCESS_NOT_ALLOWED_THROTTLED_V02 = 6, /**<  DL processing via server is not allowed due to throttling but will be
+       processed locally   */
+  eQMI_LOC_GTP_PROCESS_NOT_ALLOWED_OTHER_V02 = 7, /**<  DL processing via server is not allowed for any other reason but will be
+       processed locally    */
+  eQMI_LOC_GTP_PROCESS_FAILED_UNSPECIFIED_V02 = 8, /**<  DL processing failed for any other reason   */
+  QMILOCGTPPROCESSSTATUSENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocGtpProcessStatusEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Sends a GTP message to MP notifying MP of AP download response. */
+typedef struct {
+
+  /* Mandatory */
+  /*  GDT Service ID */
+  qmiLocGdtServiceIdEnumT_v02 serviceId;
+  /**<   Values: \n
+
+      - eQMI_LOC_GDT_SERVICE_WWAN (1) --  GDT service for WWAN UL
+      - eQMI_LOC_GDT_SERVICE_WWAN_DL (2) --  GDT service for WWAN DL  */
+
+  /* Mandatory */
+  /*  Session ID */
+  uint32_t sessionId;
+  /**<   Session ID. */
+
+  /* Mandatory */
+  /*  AP Process Status */
+  qmiLocGtpProcessStatusEnumT_v02 processingStatus;
+  /**<   AP processing status information for this service ID.
+
+ Valid values: \n
+      - eQMI_LOC_GTP_PROCESS_SUCCESS_FROM_LOCAL (1) --  DL processing is processed successfully locally
+      - eQMI_LOC_GTP_PROCESS_SUCCESS_FROM_SERVER (2) --  DL processing is processed successfully via server access
+      - eQMI_LOC_GTP_PROCESS_NOT_ALLOWED_AP_NOT_READY (3) --  DL processing is not allowed because the AP is not ready
+      - eQMI_LOC_GTP_PROCESS_NOT_ALLOWED_AP_TIMEOUT (4) --  DL processing is not allowed because the AP cannot process within the given interval
+      - eQMI_LOC_GTP_PROCESS_NOT_ALLOWED_NO_CONNECTIVITY (5) --  DL processing via server is not allowed since AP has no connectivity but
+       will be processed locally
+      - eQMI_LOC_GTP_PROCESS_NOT_ALLOWED_THROTTLED (6) --  DL processing via server is not allowed due to throttling but will be
+       processed locally
+      - eQMI_LOC_GTP_PROCESS_NOT_ALLOWED_OTHER (7) --  DL processing via server is not allowed for any other reason but will be
+       processed locally
+      - eQMI_LOC_GTP_PROCESS_FAILED_UNSPECIFIED (8) --  DL processing failed for any other reason
+ */
+
+  /* Optional */
+  /*  WWAN Download Flag */
+  uint8_t wwanDownloadFlag_valid;  /**< Must be set to true if wwanDownloadFlag is being passed */
+  uint16_t wwanDownloadFlag;
+  /**<   WWAN download flag. */
+
+  /* Optional */
+  /*  Encoded Response Location Information */
+  uint8_t respLocInfo_valid;  /**< Must be set to true if respLocInfo is being passed */
+  uint32_t respLocInfo_len;  /**< Must be set to # of elements in respLocInfo */
+  uint8_t respLocInfo[QMI_LOC_MAX_GTP_RLI_LEN_V02];
+  /**<   Response location information encoded in asn.1 format. \n
+         - Type: Array of bytes \n
+         - Maximum length of the array: 256
+    */
+
+  /* Optional */
+  /*  AP Remaining Throttle Time */
+  uint8_t apRemainingThrottleTime_valid;  /**< Must be set to true if apRemainingThrottleTime is being passed */
+  uint32_t apRemainingThrottleTime;
+  /**<   Remaining time in seconds during which AP will remain throttled for server access. */
+}qmiLocGdtDownloadBeginStatusReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Sends a GTP message to MP notifying MP of AP download response. */
+typedef struct {
+
+  /* Mandatory */
+  /*  GDT Download Begin Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the GDT begin request.
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+}qmiLocGdtDownloadBeginStatusIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Sends a GTP message to the MP notifying it of data readiness. */
+typedef struct {
+
+  /* Mandatory */
+  /*  GDT Service ID */
+  qmiLocGdtServiceIdEnumT_v02 serviceId;
+  /**<   Values: \n
+
+      - eQMI_LOC_GDT_SERVICE_WWAN (1) --  GDT service for WWAN UL
+      - eQMI_LOC_GDT_SERVICE_WWAN_DL (2) --  GDT service for WWAN DL  */
+
+  /* Mandatory */
+  /*  Session ID */
+  uint32_t sessionId;
+  /**<   Session ID. */
+
+  /* Mandatory */
+  /*  Processing Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the AP processing request.
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Mandatory */
+  /*  Data File Path (NULL Terminated) */
+  uint32_t filePath_len;  /**< Must be set to # of elements in filePath */
+  char filePath[QMI_LOC_MAX_GDT_PATH_LEN_V02];
+  /**<   File path to the data. \n
+         - Type: Array of bytes \n
+         - Maximum length of the array: 255
+    */
+}qmiLocGdtDownloadReadyStatusReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Sends a GTP message to the MP notifying it of data readiness. */
+typedef struct {
+
+  /* Mandatory */
+  /*  GDT Ready Begin Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the GDT ready request.
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+}qmiLocGdtDownloadReadyStatusIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Acknowledges receipt of Receive Done to the GDT MP. */
+typedef struct {
+
+  /* Mandatory */
+  /*  GDT Service ID */
+  qmiLocGdtServiceIdEnumT_v02 serviceId;
+  /**<   Values: \n
+
+      - eQMI_LOC_GDT_SERVICE_WWAN (1) --  GDT service for WWAN UL
+      - eQMI_LOC_GDT_SERVICE_WWAN_DL (2) --  GDT service for WWAN DL  */
+
+  /* Mandatory */
+  /*  Session ID */
+  uint32_t sessionId;
+  /**<   Session ID. */
+
+  /* Mandatory */
+  /*  QMI LOC Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Values: \n
+
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure  */
+}qmiLocGdtReceiveDoneStatusReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Acknowledges receipt of Receive Done to the GDT MP. */
+typedef struct {
+
+  /* Mandatory */
+  /*  GDT Receive Done Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Receive Done request.
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+}qmiLocGdtReceiveDoneStatusIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Acknowledges the receipt of download completion to the GDT MP. */
+typedef struct {
+
+  /* Mandatory */
+  /*  GDT Service ID */
+  qmiLocGdtServiceIdEnumT_v02 serviceId;
+  /**<   Values: \n
+
+      - eQMI_LOC_GDT_SERVICE_WWAN (1) --  GDT service for WWAN UL
+      - eQMI_LOC_GDT_SERVICE_WWAN_DL (2) --  GDT service for WWAN DL  */
+
+  /* Mandatory */
+  /*  Session ID */
+  uint32_t sessionId;
+  /**<   Session ID. */
+
+  /* Mandatory */
+  /*  QMI LOC Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Values: \n
+
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure  */
+}qmiLocGdtDownloadEndStatusReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Acknowledges the receipt of download completion to the GDT MP. */
+typedef struct {
+
+  /* Mandatory */
+  /*  GDT Download End Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the GDT download end request.
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+}qmiLocGdtDownloadEndStatusIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCDBTUSAGEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_DBT_USAGE_NAVIGATION_V02 = 1, /**<  Navigation usage type  */
+  QMILOCDBTUSAGEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocDbtUsageEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCDBDISTANCETYPEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_DBT_DISTANCE_TYPE_STRAIGHT_LINE_V02 = 1, /**<  Straight line distance between
+       location updates   */
+  QMILOCDBDISTANCETYPEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocDbDistanceTypeEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to initiate a Distance Based Tracking (DBT) session. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Request ID */
+  uint8_t reqId;
+  /**<   ID of the request as identified by the control point. The request ID
+       is reported back in the position reports. The control point must
+       specify the same request ID in the QMI_LOC_STOP_DBT_REQ message. \n
+       - Range: 0 to 255
+  */
+
+  /* Mandatory */
+  /*  Minimum Distance Between Position Reports */
+  uint32_t minDistance;
+  /**<   Minimum distance, specified by the control point,
+       that must be traversed between position reports. \n
+       - Units: Meters
+  */
+
+  /* Mandatory */
+  /*  Type of Distance to be Tracked */
+  qmiLocDbDistanceTypeEnumT_v02 distanceType;
+  /**<   Straight line distance or accumulated distance. \n
+
+ Valid values: \n
+      - eQMI_LOC_DBT_DISTANCE_TYPE_STRAIGHT_LINE (1) --  Straight line distance between
+       location updates
+ */
+
+  /* Mandatory */
+  /*  Need Origin Location */
+  uint8_t needOriginLocation;
+  /**<   Indicates whether the control point wants the position
+       corresponding to the origin. \begin{itemize1}
+       \item    0x01 (TRUE)  -- Control point is requesting origin
+                                location
+       \item    0x00 (FALSE) -- Control point is not requesting origin
+                                location
+       \vspace{-0.18in} \end{itemize1}
+  */
+
+  /* Optional */
+  /*  Maximum Latency Threshold for Position Reports */
+  uint8_t maxLatency_valid;  /**< Must be set to true if maxLatency is being passed */
+  uint32_t maxLatency;
+  /**<   Maximum time period, specified by the control point, after the minimum
+       distance criteria has been met within which a location update must
+       be provided. If not specified, an ideal value will be assumed by the
+       engine  \n
+       - Units: seconds
+  */
+
+  /* Optional */
+  /*  Usage Type */
+  uint8_t usageType_valid;  /**< Must be set to true if usageType is being passed */
+  qmiLocDbtUsageEnumT_v02 usageType;
+  /**<   Specifies the type of usage by the control point. It refers specifically
+ to the use case category of the client. For example, a navigation client should
+ set this to QMI_LOC_USAGE_NAVIGATION for better performance in difficult
+ signal conditions, such as tunnels.
+
+ If not specified, the service uses default algorithms to provide an ideal
+ performance.
+
+ Valid values: \n
+      - eQMI_LOC_DBT_USAGE_NAVIGATION (1) --  Navigation usage type
+ */
+}qmiLocStartDbtReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to initiate a Distance Based Tracking (DBT) session. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Start DBT Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Start DBT request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Optional */
+  /*  Request ID */
+  uint8_t reqId_valid;  /**< Must be set to true if reqId is being passed */
+  uint8_t reqId;
+  /**<   ID of the DBT start request for which this
+       indication was generated. */
+}qmiLocStartDbtIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to stop a DBT session. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Request ID */
+  uint8_t reqId;
+  /**<   ID of the request that was specified in the Start DBT
+        request (QMI_LOC_START_DBT_REQ).\n
+       - Range: 0 to 255 */
+}qmiLocStopDbtReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to stop a DBT session. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Stop DBT Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Stop DBT request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Optional */
+  /*  Request ID */
+  uint8_t reqId_valid;  /**< Must be set to true if reqId is being passed */
+  uint8_t reqId;
+  /**<   ID of the DBT stop request for which this
+       indication was generated. */
+}qmiLocStopDbtIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCDBTPOSITIONTYPEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_DBT_POSITION_TYPE_ORIGIN_V02 = 1, /**<  Position reported is at the origin  */
+  eQMI_LOC_DBT_POSITION_TYPE_TRACKING_V02 = 2, /**<  Position reported is a tracking type
+       where the origin location has already
+       been reported  */
+  QMILOCDBTPOSITIONTYPEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocDbtPositionTypeEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  /*  UTC Timestamp */
+  uint64_t timestampUtc;
+  /**<   UTC timestamp. \n
+       - Units: Milliseconds since Jan. 1, 1970
+  */
+
+  /*  Latitude */
+  double latitude;
+  /**<   Latitude (specified in WGS84 datum).
+       \begin{itemize1}
+       \item    Type: Floating point
+       \item    Units: Degrees
+       \item    Range: -90.0 to 90.0       \begin{itemize1}
+         \item    Positive values indicate northern latitude
+         \item    Negative values indicate southern latitude
+       \vspace{-0.18in} \end{itemize1} \end{itemize1} */
+
+  /*   Longitude */
+  double longitude;
+  /**<   Longitude (specified in WGS84 datum).
+       \begin{itemize1}
+       \item    Type: Floating point
+       \item    Units: Degrees
+       \item    Range: -180.0 to 180.0     \begin{itemize1}
+         \item    Positive values indicate eastern longitude
+         \item    Negative values indicate western longitude
+       \vspace{-0.18in} \end{itemize1} \end{itemize1} */
+
+  /*  Horizontal Elliptical Uncertainty (Semi-Minor Axis) */
+  float horUncEllipseSemiMinor;
+  /**<   Semi-minor axis of horizontal elliptical uncertainty.\n
+       - Units: Meters */
+
+  /*  Horizontal Elliptical Uncertainty (Semi-Major Axis) */
+  float horUncEllipseSemiMajor;
+  /**<   Semi-major axis of horizontal elliptical uncertainty.\n
+       - Units: Meters */
+
+  /*  Elliptical Horizontal Uncertainty Azimuth */
+  float horUncEllipseOrientAzimuth;
+  /**<   Elliptical horizontal uncertainty azimuth of orientation.\n
+       - Units: Decimal degrees \n
+       - Range: 0 to 180 */
+
+  /*  Horizontal Speed Validity Bit */
+  uint8_t speedHorizontal_valid;
+  /**<   Indicates whether the horizontal speed field contains valid
+       information.        \n
+       - 0x01 (TRUE)  --  Horizontal speed is valid \n
+       - 0x00 (FALSE) --  Horizontal speed is invalid
+                                 and is to be ignored \vspace{-0.18in}
+  */
+
+  /*  Horizontal Speed */
+  float speedHorizontal;
+  /**<   Horizontal speed.\n
+       - Units: Meters/second */
+
+  /*  Altitude Validity Bit */
+  uint8_t altitudeWrtEllipsoid_valid;
+  /**<   Indicates whether the altitude field contains valid
+       information.        \n
+       - 0x01 (TRUE)  --  Altitude field is valid \n
+       - 0x00 (FALSE) --  Altitude field is invalid
+                                 and is to be ignored \vspace{-0.18in}
+       */
+
+  /*  Altitude With Respect to Ellipsoid */
+  float altitudeWrtEllipsoid;
+  /**<   Altitude with respect to the WGS84 ellipsoid.\n
+       - Units: Meters \n
+       - Range: -500 to 15883 */
+
+  /*  Vertical Uncertainty Validity Bit */
+  uint8_t vertUnc_valid;
+  /**<   Indicates whether the vertical uncertainty field contains valid
+       information. \n
+       - 0x01 (TRUE)  --  Vertical Uncertainty field is valid \n
+       - 0x00 (FALSE) --  Vertical Uncertainty field is invalid
+                                 and is to be ignored \vspace{-0.18in}
+  */
+
+  /*  Vertical Uncertainty */
+  float vertUnc;
+  /**<   Vertical uncertainty.\n
+       - Units: Meters */
+
+  /*  Vertical Speed Validity Bit */
+  uint8_t speedVertical_valid;
+  /**<   Indicates whether the vertical speed field contains valid
+       information. \n
+       - 0x01 (TRUE)  --  Vertical Speed field is valid \n
+       - 0x00 (FALSE) --  Vertical Speed field is invalid
+                                 and is to be ignored \vspace{-0.18in}
+  */
+
+  /*  Vertical Speed */
+  float speedVertical;
+  /**<   Vertical speed.\n
+       - Units: Meters/second */
+
+  /*  Heading Validity Bit */
+  uint8_t heading_valid;
+  /**<   Indicates whether the heading field contains valid
+       information.        \n
+       - 0x01 (TRUE)  --  Heading field is valid \n
+       - 0x00 (FALSE) --  Heading field is invalid
+                                 and is to be ignored \vspace{-0.18in}
+  */
+
+  /*  Heading */
+  float heading;
+  /**<   Heading.\n
+        - Units: Degrees \n
+        - Range: 0 to 359.999  */
+}qmiLocDbtPositionStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Notifies the control point of
+                    a DBT position report. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Request ID */
+  uint8_t reqId;
+  /**<   ID of the DBT request for which this
+       report was generated. */
+
+  /* Mandatory */
+  /*  DBT Position */
+  qmiLocDbtPositionStructT_v02 dbtPosition;
+  /**<   Position of the client when it has traversed the
+       specified distance.
+       */
+
+  /* Mandatory */
+  /*  DBT Position Type */
+  qmiLocDbtPositionTypeEnumT_v02 positionType;
+  /**<   Specifies whether the position reported is at the
+ origin of the DBT session or during the tracking
+ duration of the session. Values: \n
+
+      - eQMI_LOC_DBT_POSITION_TYPE_ORIGIN (1) --  Position reported is at the origin
+      - eQMI_LOC_DBT_POSITION_TYPE_TRACKING (2) --  Position reported is a tracking type
+       where the origin location has already
+       been reported  */
+
+  /* Optional */
+  /*  Heading Uncertainty */
+  uint8_t headingUnc_valid;  /**< Must be set to true if headingUnc is being passed */
+  float headingUnc;
+  /**<   Heading uncertainty.\n
+           - Units: Degrees \n
+           - Range: 0 to 359.999 */
+
+  /* Optional */
+  /*  Speed Uncertainty */
+  uint8_t speedUnc_valid;  /**< Must be set to true if speedUnc is being passed */
+  float speedUnc;
+  /**<   3-D speed uncertainty.\n
+           - Units: Meters/second */
+
+  /* Optional */
+  /*  Horizontal Confidence */
+  uint8_t horConfidence_valid;  /**< Must be set to true if horConfidence is being passed */
+  uint8_t horConfidence;
+  /**<   Horizontal uncertainty confidence.\n
+           - Units: Percent \n
+           - Range: 0 to 99 */
+
+  /* Optional */
+  /*  Vertical Confidence */
+  uint8_t vertConfidence_valid;  /**< Must be set to true if vertConfidence is being passed */
+  uint8_t vertConfidence;
+  /**<   Vertical uncertainty confidence.\n
+           - Units: Percent \n
+           - Range: 0 to 99 */
+
+  /* Optional */
+  /*  Dilution of Precision */
+  uint8_t DOP_valid;  /**< Must be set to true if DOP is being passed */
+  qmiLocDOPStructT_v02 DOP;
+  /**<   \vspace{0.06in} \n Dilution of precision associated with this position. */
+
+  /* Optional */
+  /*  SVs Used to Calculate the Fix */
+  uint8_t gnssSvUsedList_valid;  /**< Must be set to true if gnssSvUsedList is being passed */
+  uint32_t gnssSvUsedList_len;  /**< Must be set to # of elements in gnssSvUsedList */
+  uint16_t gnssSvUsedList[QMI_LOC_MAX_SV_USED_LIST_LENGTH_V02];
+  /**<   Each entry in the list contains the SV ID of a satellite
+          used for calculating this position report. The following
+          information is associated with each SV ID: \n
+        Range:    \n
+      - For GPS:     1 to 32 \n
+      - For GLONASS: 65 to 96 \n
+      - For SBAS:    120 to 158 and 183 to 187 \n
+      - For QZSS:    193 to 197 \n
+      - For BDS:     201 to 237 \n
+      - For GAL:     301 to 336
+  */
+
+  /* Optional */
+  /*  Position Source */
+  uint8_t positionSrc_valid;  /**< Must be set to true if positionSrc is being passed */
+  qmiLocPositionSrcEnumT_v02 positionSrc;
+  /**<   Source from which this position was obtained.
+ Valid values: \n
+      - eQMI_LOC_POSITION_SRC_GNSS (0) --  Position source is GNSS
+      - eQMI_LOC_POSITION_SRC_CELLID (1) --  Position source is Cell ID
+      - eQMI_LOC_POSITION_SRC_ENH_CELLID (2) --  Position source is Enhanced Cell ID
+      - eQMI_LOC_POSITION_SRC_WIFI (3) --  Position source is Wi-Fi
+      - eQMI_LOC_POSITION_SRC_TERRESTRIAL (4) --  Position source is Terrestrial
+      - eQMI_LOC_POSITION_SRC_GNSS_TERRESTRIAL_HYBRID (5) --  Position source is GNSS Terrestrial Hybrid
+      - eQMI_LOC_POSITION_SRC_OTHER (6) --  Other sources
+ */
+}qmiLocEventDbtPositionReportIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCDBTSESSIONSTATUSENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_DBT_UNABLE_TO_TRACK_V02 = 1, /**<  Distance based tracking  is unavailable and DBT fixes
+       cannot currently be obtained  */
+  eQMI_LOC_DBT_ABLE_TO_TRACK_V02 = 2, /**<  Distance based tracking  is available and DBT fixes
+       can currently be obtained  */
+  QMILOCDBTSESSIONSTATUSENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocDbtSessionStatusEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Notifies the control point of the
+                    DBT session status. */
+typedef struct {
+
+  /* Mandatory */
+  /*  DBT Session Status */
+  qmiLocDbtSessionStatusEnumT_v02 dbtSessionStatus;
+  /**<   Specifies the DBT session status type.
+
+ Valid values: \n
+      - eQMI_LOC_DBT_UNABLE_TO_TRACK (1) --  Distance based tracking  is unavailable and DBT fixes
+       cannot currently be obtained
+      - eQMI_LOC_DBT_ABLE_TO_TRACK (2) --  Distance based tracking  is available and DBT fixes
+       can currently be obtained
+ */
+
+  /* Optional */
+  /*  Request ID */
+  uint8_t reqId_valid;  /**< Must be set to true if reqId is being passed */
+  uint8_t reqId;
+  /**<   ID of the DBT request for which this
+       status was generated. */
+}qmiLocEventDbtSessionStatusIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCPOSITIONSOURCEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_POS_SRC_GNSS_V02 = 1, /**<  Source of the position is GNSS  */
+  QMILOCPOSITIONSOURCEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocPositionSourceEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCPOSITIONRPTPROPAGATIONENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_POS_REPORT_PROPAGATED_TO_CURRENT_UTC_V02 = 1, /**<  Reported position is propagated to the current UTC  */
+  QMILOCPOSITIONRPTPROPAGATIONENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocPositionRptPropagationEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCSECURELOCDATAMODEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_SECURE_LOC_DATA_ENCRYPTED_V02 = 1, /**<  Data in the indication is to be encrypted  */
+  eQMI_LOC_SECURE_LOC_DATA_UNENCRYPTED_V02 = 2, /**<  Data in the indication is to be unencrypted  */
+  QMILOCSECURELOCDATAMODEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocSecureLocDataModeEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCSECUREGETAVAILABLEPOSPARAMETERIDENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_PARAM_TRANSACTION_ID_V02 = 1, /**<  Parameter ID for the Transaction ID field. Mandatory field.
+       Identifies the transaction. The transaction ID is returned in the
+       Secured Get Available Position indication. \n
+       - Parameter type: uint32
+   */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_PARAM_NONCE_V02 = 2, /**<  Parameter ID for the Nonce field. Optional field.
+       - Parameter type: uint64
+   */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_PARAM_SOURCE_V02 = 3, /**<  Parameter ID for the Position Source field. Optional field.
+       Specifies the source of the position in which the control point is interest.
+       If not included, the value defaults to GNSS.        \n
+       - Parameter type: int32 \n
+       Parameter valid values: \n
+       - eQMI_LOC_POS_SRC_GNSS (1) --  Source of the position is GNSS
+   */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_PARAM_REPORT_DATA_SECURITY_MODE_V02 = 4, /**<  Secured position report data security mode. Optional field.
+       If this TLV is not sent, the position report is encrypted by default. \n
+       - Parameter type: int32 \n
+       Parameter valid values: \n
+       - eQMI_LOC_SECURE_LOC_DATA_ENCRYPTED (1)   --  Position reports are encrypted
+       - eQMI_LOC_SECURE_LOC_DATA_UNENCRYPTED (2) --  Position reports are not encrypted
+    */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_PARAM_REPORT_DATA_TIME_PROPAGATION_V02 = 5, /**<  Secured position report data propagation.  Optional field.
+       If this TLV is not sent, the position report is propagated to the current UTC time by default. \n
+       - Parameter type: int32 \n
+       Parameter valid values: \n
+       - eQMI_LOC_POS_REPORT_PROPAGATED_TO_CURRENT_UTC (1) -- Position reports are propagated to the current UTC. \n
+    */
+  QMILOCSECUREGETAVAILABLEPOSPARAMETERIDENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocSecureGetAvailablePosParameterIDEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCSECUREMESSAGEDATATYPEENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_SECURE_DATA_TYPE_BYTE_8_V02 = 1, /**<  Data type: Byte (8 bits)  */
+  eQMI_LOC_SECURE_DATA_TYPE_CHAR_8_V02 = 2, /**<  Data type: Char (8 bits)  */
+  eQMI_LOC_SECURE_DATA_TYPE_UNSIGNED_CHAR_8_V02 = 3, /**<  Data type: Unsigned char (8 bits)  */
+  eQMI_LOC_SECURE_DATA_TYPE_INT_8_V02 = 4, /**<  Data type: Int (8 bits)  */
+  eQMI_LOC_SECURE_DATA_TYPE_UNSIGNED_INT_8_V02 = 5, /**<  Data type: Unsigned int (8 bits)  */
+  eQMI_LOC_SECURE_DATA_TYPE_INT_16_V02 = 6, /**<  Data type: Int (16 bits)  */
+  eQMI_LOC_SECURE_DATA_TYPE_UNSIGNED_INT_16_V02 = 7, /**<  Data type: Unsigned int (16 bits)  */
+  eQMI_LOC_SECURE_DATA_TYPE_INT_32_V02 = 8, /**<  Data type: Int (32 bits)  */
+  eQMI_LOC_SECURE_DATA_TYPE_UNSIGNED_INT_32_V02 = 9, /**<  Data type: Unsigned int (32 bits)  */
+  eQMI_LOC_SECURE_DATA_TYPE_INT_64_V02 = 10, /**<  Data type: Int (64 bits)  */
+  eQMI_LOC_SECURE_DATA_TYPE_UNSIGNED_INT_64_V02 = 11, /**<  Data type: Unsigned int (64 bits)  */
+  eQMI_LOC_SECURE_DATA_TYPE_BOOL_8_V02 = 12, /**<  Data type: Boolean (8 bits)  */
+  eQMI_LOC_SECURE_DATA_TYPE_DOUBLE_64_V02 = 13, /**<  Data type: Double (64 bits)  */
+  eQMI_LOC_SECURE_DATA_TYPE_FLOAT_32_V02 = 14, /**<  Data type: Float (32 bits)  */
+  QMILOCSECUREMESSAGEDATATYPEENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocSecureMessageDataTypeEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to get the available
+                    position estimate from the location engine. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Data Security Mode for Encoded Data Buffer */
+  qmiLocSecureLocDataModeEnumT_v02 secureLocDataMode;
+  /**<   Data security mode for the encoded data buffer.
+
+ Valid values: \n
+      - eQMI_LOC_SECURE_LOC_DATA_ENCRYPTED (1) --  Data in the indication is to be encrypted
+      - eQMI_LOC_SECURE_LOC_DATA_UNENCRYPTED (2) --  Data in the indication is to be unencrypted
+ */
+
+  /* Mandatory */
+  /*  Encoded Data Buffer Containing Secure Get Available Position Request Parameters */
+  uint32_t qmilocSecureGetAvailablePositionRequestData_len;  /**< Must be set to # of elements in qmilocSecureGetAvailablePositionRequestData */
+  uint8_t qmilocSecureGetAvailablePositionRequestData[QMI_LOC_SECURE_GET_AVAILABLE_POS_REQUEST_ENCRYPTED_MAX_V02];
+  /**<   Encoded data buffer containing the secure Get Available Position Request parameters. */
+}qmiLocSecureGetAvailablePositionReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCSECUREGETAVAILABLEPOSITIONINDPARAMIDENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_REP_PARAM_TRANSACTION_ID_V02 = 1, /**<  Parameter ID for the Transaction ID field. Mandatory field.
+             Transaction ID that was specified in the Secured Get Available Position request.
+             This parameter is always present if the status field is set to SUCCESS. \n
+                - Parameter type: uint32
+         */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_REP_PARAM_NONCE_V02 = 2, /**<  Parameter ID for the Secure Session Nonce.
+             This echos back the Nonce received from the Secured Get Available Position Request.
+             Optional field. \n
+                - Parameter type: uint64
+         */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_REP_PARAM_LATITUDE_V02 = 3, /**<   Parameter ID for Latitude (specified in WGS84 datum). Optional field.
+        \begin{itemize1}
+        \item    Parameter type: Floating point
+        \item    Parameter units: Degrees
+        \item    Parameter range: -90.0 to 90.0       \begin{itemize1}
+          \item    Positive values indicate northern latitude
+          \item    Negative values indicate southern latitude
+        \vspace{-0.18in} \end{itemize1} \end{itemize1}  */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_REP_PARAM_LONGITUDE_V02 = 4, /**<   Parameter ID for Longitude (specified in WGS84 datum). Optional field.
+        \begin{itemize1}
+        \item    Parameter type: Floating point
+        \item    Parameter units: Degrees
+        \item    Parameter range: -180.0 to 180.0     \begin{itemize1}
+        \item    Positive values indicate eastern longitude
+        \item    Negative values indicate western longitude
+        \vspace{-0.18in} \end{itemize1} \end{itemize1}  */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_REP_PARAM_HORIZ_UNC_CIRCULAR_V02 = 5, /**<   Parameter ID for Circular Horizontal Uncertainty. Optional field. \n
+        - Parameter tnits: Meters \n
+        - Parameter type: Float  */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_REP_PARAM_ALTITUDE_WRT_ELP_V02 = 6, /**<   Parameter ID for altitude with respect to the WGS84 ellipsoid. Optional field. \n
+        - Parameter units: Meters \n
+        - Parameter range: -500 to 15883 \n
+        - Parameter type: Float  */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_REP_PARAM_VERTICAL_UNC_V02 = 7, /**<   Parameter ID for Vertical Uncertainty. Optional field.\n
+        - Parameter units: Meters \n
+        - Parameter type: Float  */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_REP_PARAM_TIME_STAMP_UTC_V02 = 8, /**<   Parameter ID for the UTC timestamp. Optional field.\n
+        - Parameter type: uint64 \n
+        - Parameter units: Milliseconds since Jan. 1, 1970
+         */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_REP_PARAM_TIME_UNC_V02 = 9, /**<   Parameter ID for time uncertainty. Optional field.\n
+           - Parameter type: Float \n
+           - Parameter units: Milliseconds  */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_REP_PARAM_HORIZ_UNC_ELP_SEMIMINOR_V02 = 10, /**<   Parameter ID for the Semi-Minor Axis of Horizontal Elliptical Uncertainty. Optional field.\n
+           - Parameter mnits: Meters \n
+           - Parameter type: Float  */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_REP_PARAM_HORIZ_UNC_ELP_SEMIMAJOR_V02 = 11, /**<   Parameter ID for the Semi-Major Axis of Horizontal Elliptical Uncertainty. Optional field.\n
+           - Parameter units: Meters \n
+           - Parameter type: Float */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_REP_PARAM_HORIZ_UNC_ELP_ORIENT_AZIMUTH_V02 = 12, /**<   Parameter ID for the Elliptical Horizontal Uncertainty Azimuth of orientation. Optional field.\n
+           - Parameter units: Decimal degrees \n
+           - Parameter range: 0 to 180 \n
+           - Parameter type: Float  */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_REP_PARAM_HORIZ_CONFIDENCE_V02 = 13, /**<   Parameter ID for Horizontal uncertainty confidence. Optional field.\n
+       If both elliptical and horizontal uncertainties are specified in this message,
+       the confidence corresponds to the elliptical uncertainty. Optional field.\n
+           - Parameter units: Percent \n
+           - Parameter range: 0 to 99 \n
+           - Parameter type: uint8 */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_REP_PARAM_HORIZ_ELLIP_CONFIDENCE_V02 = 14, /**<   Parameter ID for Horizontal Elliptical Uncertainty Confidence. Optional field.\n
+       If both elliptical and horizontal uncertainties are specified in this message,
+       the confidence corresponds to the elliptical uncertainty. Optional field.\n
+           - Parameter units: Percent \n
+           - Parameter range: 0 to 99 \n
+           - Parameter type: uint8 */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_REP_PARAM_HORIZ_RELIABILITY_V02 = 15, /**<   Parameter ID for Specifies the reliability of the horizontal position. Optional field.
+           - Parameter Type: int32 \n
+       Parameter valid values: \n
+           - RELIABILITY_NOT_SET   = 0 \n
+           - RELIABILITY_VERY_LOW  = 1 \n
+           - RELIABILITY_LOW       = 2 \n
+           - RELIABILITY_MEDIUM    = 3 \n
+           - RELIABILITY_HIGH      = 4
+         */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_REP_PARAM_SPEED_HORIZ_V02 = 16, /**<   Parameter ID for Horizontal Speed. Optional field.\n
+           - Parameter units: Meters/second \n
+           - Parameter type: Float  */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_REP_PARAM_SPEED_HORIZ_UNC_V02 = 17, /**<   Parameter ID for Horizontal Speed Uncertainty. Optional field.\n
+           - Parameter units: Meters/second \n
+           - Parameter type: Float  */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_REP_PARAM_ALTITUDE_WRT_MSA_V02 = 18, /**<   Parameter ID for Altitude with respect to mean sea level. Optional field.\n
+           - Parameter units: Meters \n
+           - Parameter type: Float  */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_REP_PARAM_VERTICAL_CONF_V02 = 19, /**<   Parameter ID for Vertical uncertainty confidence. Optional field.\n
+           - Parameter units: Percent \n
+           - Parameter range: 0 to 99 \n
+           - Parameter type: uint8 */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_REP_PARAM_VERT_RELIABILITY_V02 = 20, /**<   Parameter ID for specifies the reliability of the vertical position. Optional field. \n
+           - Parameter type: int32 \n
+           Parameter valid values: \n
+                - RELIABILITY_NOT_SET   = 0 \n
+                - RELIABILITY_VERY_LOW  = 1 \n
+                - RELIABILITY_LOW       = 2 \n
+                - RELIABILITY_MEDIUM    = 3 \n
+                - RELIABILITY_HIGH      = 4
+         */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_REP_PARAM_SPEED_VERTICAL_V02 = 21, /**<   Parameter ID for Vertical Speed. Optional field.\n
+           - Parameter units: Meters/second \n
+           - Parameter type: Float  */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_REP_PARAM_SPEED_VERTICAL_UNC_V02 = 22, /**<   Parameter ID for Vertical Speed Uncertainty. Optional field.\n
+           - Parameter units: Meters/second \n
+           - Parameter type: Float  */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_REP_PARAM_HEADING_V02 = 23, /**<   Parameter ID for Heading. Optional field.\n
+           - Parameter units: Degrees \n
+           - Parameter range: 0 to 359.999 \n
+           - Parameter type: Float  */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_REP_PARAM_HEADING_UNC_V02 = 24, /**<   Parameter ID for Heading Uncertainty. Optional field.\n
+            - Parameter units: Degrees \n
+            - Parameter range: 0 to 359.999 \n
+            - Parameter type: Float  */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_REP_PARAM_MAGNETIC_DEVIATION_V02 = 25, /**<   Parameter ID for Magnetic Deviation. Optional field.\n
+        Difference between the bearing to true north and the bearing shown
+        on a magnetic compass. The deviation is positive when the magnetic
+        north is east of true north.
+            - Parameter type: Float  */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_REP_PARAM_TECH_MASK_V02 = 26, /**<  Parameter ID for Technology Used in computing this fix. Optional field.\n
+           - Parameter type: uint32        \n
+       Parameter valid bitmasks: \n
+       - QMI_LOC_POS_TECH_MASK_SATELLITE                = 0x00000001,
+       - QMI_LOC_POS_TECH_MASK_CELLID                   = 0x00000002,
+       - QMI_LOC_POS_TECH_MASK_WIFI                     = 0x00000004,
+       - QMI_LOC_POS_TECH_MASK_SENSORS                  = 0x00000008,
+       - QMI_LOC_POS_TECH_MASK_REFERENCE_LOCATION       = 0x00000010,
+       - QMI_LOC_POS_TECH_MASK_INJECTED_COARSE_POSITION = 0x00000020,
+       - QMI_LOC_POS_TECH_MASK_AFLT                     = 0x00000040,
+       - QMI_LOC_POS_TECH_MASK_HYBRID                   = 0x00000080
+         */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_REP_PARAM_PDOP_V02 = 27, /**<  Parameter ID for Position Dilution of Precision associated with this position. Optional field.\n
+           - Parameter type: Float
+           - Parameter range: 1 (highest accuracy) to 50 (lowest accuracy)
+           - PDOP = square root of (HDOP^2 + VDOP^2)
+         */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_REP_PARAM_HDOP_V02 = 28, /**<  Parameter ID for Horizontal Dilution of Precision associated with this position. Optional field.\n
+           - Parameter type: Float
+           - Parameter range: 1 (highest accuracy) to 50 (lowest accuracy)
+         */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_REP_PARAM_VDOP_V02 = 29, /**<  Parameter ID for Vertical Dilution of Precision associated with this position. Optional field.\n
+           - Parameter type: Float
+           - Parameter range: 1 (highest accuracy) to 50 (lowest accuracy)
+         */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_REP_PARAM_GPS_WEEK_V02 = 30, /**<  Parameter ID for the current GPS Week, as calculated from midnight, Jan. 6, 1980. Optional field.\n
+           - Parameter type: uint16
+           - Parameter units: Weeks
+         */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_REP_PARAM_GPS_TIMEOFWEEKMS_V02 = 31, /**<  Parameter ID for amount of time into the current GPS Week. Optional field.\n
+           - Parameter type: uint32
+           - Parameter units: Milliseconds
+         */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_REP_PARAM_TIME_SRC_V02 = 32, /**<  Parameter ID for Time Source. Optional field.\n
+           - Parameter type: uint32 (enum qmiLocTimeSourceEnumT)
+         */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_REP_SENSOR_USAGE_MASK_V02 = 33, /**<  Parameter ID that specifies which sensors were used in calculating the position in the
+        position report. Optional field.\n
+            - Parameter type: uint32 \n
+        Parameter valid bitmasks: \n
+            - 0x00000001 -- SENSOR_USED_ACCEL \n
+            - 0x00000002 -- SENSOR_USED_GYRO
+         */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_REP_AIDING_IND_MASK_V02 = 34, /**<  Parameter ID that specifies which which results were aided by sensors. Optional field.\n
+            - Parameter type: uint32 \n
+        Parameter valid bitmasks: \n
+            - 0x00000001 -- AIDED_HEADING \n
+            - 0x00000002 -- AIDED_SPEED \n
+            - 0x00000004 -- AIDED_POSITION \n
+            - 0x00000008 -- AIDED_VELOCITY
+         */
+  eQMI_LOC_SECURE_GET_AVAILABLE_POS_REP_PARAM_SV_USED_V02 = 35, /**<  Each entry in the list contains the SV ID of a satellite
+       used for calculating this position report. The following
+       information is associated with each SV ID.  Optional field. \n
+           - Parameter type: uint16        \n
+       Parameter range: \n
+       - For GPS:     1 to 32  \n
+       - For SBAS:    33 to 64  \n
+       - For GLONASS: 65 to 96 \n
+       - For QZSS:    193 to 197 \n
+       - For BDS:     201 to 237
+     */
+  QMILOCSECUREGETAVAILABLEPOSITIONINDPARAMIDENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocSecureGetAvailablePositionIndParamIDEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to get the available
+                    position estimate from the location engine. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Session Status */
+  qmiLocSessionStatusEnumT_v02 sessionStatus;
+  /**<   Session status.
+
+ Valid values: \n
+      - eQMI_LOC_SESS_STATUS_SUCCESS (0) --  Session was successful
+      - eQMI_LOC_SESS_STATUS_IN_PROGRESS (1) --  Session is still in progress; further position reports will be generated
+       until either the fix criteria specified by the client are met or the
+       client response timeout occurs
+      - eQMI_LOC_SESS_STATUS_GENERAL_FAILURE (2) --  Session failed
+      - eQMI_LOC_SESS_STATUS_TIMEOUT (3) --  Fix request failed because the session timed out
+      - eQMI_LOC_SESS_STATUS_USER_END (4) --  Fix request failed because the session was ended by the user
+      - eQMI_LOC_SESS_STATUS_BAD_PARAMETER (5) --  Fix request failed due to bad parameters in the request
+      - eQMI_LOC_SESS_STATUS_PHONE_OFFLINE (6) --  Fix request failed because the phone is offline
+      - eQMI_LOC_SESS_STATUS_ENGINE_LOCKED (7) --  Fix request failed because the engine is locked
+ */
+
+  /* Mandatory */
+  /*  Data Security Mode for Encoded Data Buffer. */
+  qmiLocSecureLocDataModeEnumT_v02 secureLocDataMode;
+  /**<   Data security mode for encoded data buffer.
+
+ Valid values: \n
+      - eQMI_LOC_SECURE_LOC_DATA_ENCRYPTED (1) --  Data in the indication is to be encrypted
+      - eQMI_LOC_SECURE_LOC_DATA_UNENCRYPTED (2) --  Data in the indication is to be unencrypted
+ */
+
+  /* Optional */
+  /*  Encoded Data Buffer Containing Secured Get Available Position Report Indication  */
+  uint8_t qmilocSecureGetAvailablePositionInd_valid;  /**< Must be set to true if qmilocSecureGetAvailablePositionInd is being passed */
+  uint32_t qmilocSecureGetAvailablePositionInd_len;  /**< Must be set to # of elements in qmilocSecureGetAvailablePositionInd */
+  uint8_t qmilocSecureGetAvailablePositionInd[QMI_LOC_SECURE_GET_AVAILABLE_POSITION_IND_ENCRYPTED_MAX_V02];
+  /**<   Encoded data buffer containing the secured Get Available Position Report indication.*/
+}qmiLocSecureGetAvailablePositionIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCAPRELIABILITYENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_AP_RELIABILITY_NOT_SET_V02 = 0, /**<  AP Location reliability is not set  */
+  eQMI_LOC_AP_RELIABILITY_LEVEL_1_V02 = 1, /**<  AP Location reliability level 1  */
+  eQMI_LOC_AP_RELIABILITY_LEVEL_2_V02 = 2, /**<  AP Location reliability level 2  */
+  eQMI_LOC_AP_RELIABILITY_LEVEL_3_V02 = 3, /**<  AP Location reliability level 3   */
+  eQMI_LOC_AP_RELIABILITY_LEVEL_4_V02 = 4, /**<  AP Location reliability level 4  */
+  eQMI_LOC_AP_RELIABILITY_LEVEL_5_V02 = 5, /**<  AP Location reliability level 5  */
+  eQMI_LOC_AP_RELIABILITY_LEVEL_6_V02 = 6, /**<  AP Location reliability level 6  */
+  eQMI_LOC_AP_RELIABILITY_LEVEL_7_V02 = 7, /**<  AP Location reliability level 7  */
+  QMILOCAPRELIABILITYENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocApReliabilityEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint64_t macAddress;
+  /**<   AP MAC address. */
+
+  float xLat;
+  /**<   AP latitude. \n
+       - Units: degrees */
+
+  float yLon;
+  /**<   AP longitude sensor y-axis sample. \n
+       - Units: degrees */
+
+  float mar;
+  /**<   Maximum antenna range. \n
+       - Units: Meters */
+}qmiLocApCacheStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint8_t hepeValid;
+  /**<   Indicates whether hepe data is available or not:
+       0x00 (FALSE) -- Ignore hepe data of this AP.
+       0x01 (TRUE) -- hepe data of this AP is available. */
+
+  uint16_t hepe;
+  /**<   Horizontal Estimated Position Error
+       - Units: Meters */
+
+  qmiLocApReliabilityEnumT_v02 apReliability;
+  /**<   Specifies the reliability of the AP position.
+ The lowest is eQMI_LOC_AP_RELIABILITY_LEVEL_1, and the highest is eQMI_LOC_AP_RELIABILITY_LEVEL_7,
+ The AP reliability increases as the level increases.
+ Valid values: \n
+      - eQMI_LOC_AP_RELIABILITY_NOT_SET (0) --  AP Location reliability is not set
+      - eQMI_LOC_AP_RELIABILITY_LEVEL_1 (1) --  AP Location reliability level 1
+      - eQMI_LOC_AP_RELIABILITY_LEVEL_2 (2) --  AP Location reliability level 2
+      - eQMI_LOC_AP_RELIABILITY_LEVEL_3 (3) --  AP Location reliability level 3
+      - eQMI_LOC_AP_RELIABILITY_LEVEL_4 (4) --  AP Location reliability level 4
+      - eQMI_LOC_AP_RELIABILITY_LEVEL_5 (5) --  AP Location reliability level 5
+      - eQMI_LOC_AP_RELIABILITY_LEVEL_6 (6) --  AP Location reliability level 6
+      - eQMI_LOC_AP_RELIABILITY_LEVEL_7 (7) --  AP Location reliability level 7
+ */
+}qmiLocApCacheHepeRelStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to inject APs into the cache of
+                    the low power Wi-Fi engine for fix computation. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Version Number */
+  uint8_t versionNumber;
+  /**<   AP cache protocol version number. */
+
+  /* Mandatory */
+  /*  Part Number */
+  uint8_t partNumber;
+  /**<   Multiple message part number; used for ordering AP information. */
+
+  /* Mandatory */
+  /*  Total Parts */
+  uint8_t totalParts;
+  /**<   Total number of parts or messages for a complete cache update. */
+
+  /* Mandatory */
+  /*  AP Cache Data */
+  uint32_t apCacheData_len;  /**< Must be set to # of elements in apCacheData */
+  qmiLocApCacheStructT_v02 apCacheData[QMI_LOC_APCACHE_DATA_MAX_SAMPLES_V02];
+  /**<   \vspace{4pt} \n AP cache information. */
+
+  /* Optional */
+  /*  AP Cache Hepe Data */
+  uint8_t apCacheHepeRelData_valid;  /**< Must be set to true if apCacheHepeRelData is being passed */
+  uint32_t apCacheHepeRelData_len;  /**< Must be set to # of elements in apCacheHepeRelData */
+  qmiLocApCacheHepeRelStructT_v02 apCacheHepeRelData[QMI_LOC_APCACHE_DATA_MAX_SAMPLES_V02];
+  /**<   \vspace{4pt} \n
+       The ordering of apCacheHepeRelData list should match the apCacheData list.
+       That is, the first element of the apCacheHepeRelData must be the cache hepe data of the AP
+       whose cache data is the first element in the apCacheData, and so on. */
+}qmiLocInjectApCacheDataReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to inject APs into the cache of
+                    the low power Wi-Fi engine for fix computation. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Set Inject APCACHE Data Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Inject AP Cache Data request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Optional */
+  /*  AP Cache Size */
+  uint8_t apCacheSize_valid;  /**< Must be set to true if apCacheSize is being passed */
+  uint32_t apCacheSize;
+  /**<   Key performance indicator (KPI) for apCacheSize that measures the size
+       of the last AP cache used. This parameter is always present. */
+
+  /* Optional */
+  /*  AP Do Not Cache Size */
+  uint8_t apDoNotCacheSize_valid;  /**< Must be set to true if apDoNotCacheSize is being passed */
+  uint32_t apDoNotCacheSize;
+  /**<   KPI for apDoNotCacheSize that measures the size of the last AP cache used.
+       This parameter is always present. */
+
+  /* Optional */
+  /*  AP Cache Hits */
+  uint8_t apCacheHits_valid;  /**< Must be set to true if apCacheHits is being passed */
+  uint32_t apCacheHits;
+  /**<   KPI for apCacheHits that measures the number of hits to the
+       AP cache of the last cache content. */
+
+  /* Optional */
+  /*  AP Do Not Cache Hits */
+  uint8_t apDoNotCacheHits_valid;  /**< Must be set to true if apDoNotCacheHits is being passed */
+  uint32_t apDoNotCacheHits;
+  /**<   KPI for apDoNotCacheHits that measures the number of hits to
+       apDoNotCache of the last cache content. */
+
+  /* Optional */
+  /*  Unknown APs */
+  uint8_t unknownAps_valid;  /**< Must be set to true if unknownAps is being passed */
+  uint32_t unknownAps;
+  /**<   KPI for unknownAps that measures the number of unknown APs, those that are
+       not found in any cache content. */
+
+  /* Optional */
+  /*  Async Scans */
+  uint8_t asyncScans_valid;  /**< Must be set to true if asyncScans is being passed */
+  uint32_t asyncScans;
+  /**<   KPI for asyncScans that measures the number of async scans
+       perceived since the last modem boot. */
+
+  /* Optional */
+  /*  Async Fixes */
+  uint8_t asyncFixes_valid;  /**< Must be set to true if asyncFixes is being passed */
+  uint32_t asyncFixes;
+  /**<   KPI for asyncFixes that measures the number of async fixes
+       generated since the last modem boot. */
+
+  /* Optional */
+  /*  Sync Scans */
+  uint8_t syncScans_valid;  /**< Must be set to true if syncScans is being passed */
+  uint32_t syncScans;
+  /**<   KPI for syncScans that measures the number of sync scans
+       perceived since the last modem boot. */
+
+  /* Optional */
+  /*  Sync Fixes */
+  uint8_t syncFixes_valid;  /**< Must be set to true if syncFixes is being passed */
+  uint32_t syncFixes;
+  /**<   KPI for asyncFixes that measures the number of sync fixes
+       generated since the last modem boot. */
+}qmiLocInjectApCacheDataIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  uint64_t macAddress;
+  /**<   AP's MAC address. */
+}qmiLocApDoNotCacheStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to inject blacked out APs into
+                    the low power location engine. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Version Number */
+  uint8_t versionNumber;
+  /**<   AP cache protocol version number. */
+
+  /* Mandatory */
+  /*  Part Number */
+  uint8_t partNumber;
+  /**<   Multiple message part number, used to order AP information. */
+
+  /* Mandatory */
+  /*  Total Parts */
+  uint8_t totalParts;
+  /**<   Total number of parts or messages for a complete cache update. */
+
+  /* Mandatory */
+  /*  No AP Cache Data */
+  uint32_t apDoNotCacheData_len;  /**< Must be set to # of elements in apDoNotCacheData */
+  qmiLocApDoNotCacheStructT_v02 apDoNotCacheData[QMI_LOC_APCACHE_DATA_MAX_SAMPLES_V02];
+  /**<   \n APDoNotCache information. */
+}qmiLocInjectApDoNotCacheDataReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to inject blacked out APs into
+                    the low power location engine. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Set Inject APDONOTCACHE Data Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Inject APDONOTCACHE Data request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+}qmiLocInjectApDoNotCacheDataIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCBATCHINGSTATUSENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_BATCH_POS_UNAVAILABLE_V02 = 1, /**<  Service is unable to compute the positions for batching  */
+  eQMI_LOC_BATCH_POS_AVAILABLE_V02 = 2, /**<  Service is able to compute the positions for batching  */
+  QMILOCBATCHINGSTATUSENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocBatchingStatusEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Notifies the control point of the
+                    batching status. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Batching Status */
+  qmiLocBatchingStatusEnumT_v02 batchingStatus;
+  /**<   Specifies the batching status.
+ Valid values: \n
+      - eQMI_LOC_BATCH_POS_UNAVAILABLE (1) --  Service is unable to compute the positions for batching
+      - eQMI_LOC_BATCH_POS_AVAILABLE (2) --  Service is able to compute the positions for batching
+ */
+}qmiLocEventBatchingStatusIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/**  Identifies the always-on service capabilities.  */
+typedef uint32_t qmiLocAonCapabilityMaskT_v02;
+#define QMI_LOC_MASK_AON_AUTO_BATCHING_SUPPORTED_V02 ((qmiLocAonCapabilityMaskT_v02)0x00000001) /**<  The service supports auto batching; the client can enable auto
+       batching by setting the distance parameter to 0 in the START_BATCHING request  */
+#define QMI_LOC_MASK_AON_DISTANCE_BASED_BATCHING_SUPPORTED_V02 ((qmiLocAonCapabilityMaskT_v02)0x00000002) /**<  The service supports distance-based batching  */
+#define QMI_LOC_MASK_AON_TIME_BASED_BATCHING_SUPPORTED_V02 ((qmiLocAonCapabilityMaskT_v02)0x00000004) /**<  The service supports time-based batching */
+#define QMI_LOC_MASK_AON_DISTANCE_BASED_TRACKING_SUPPORTED_V02 ((qmiLocAonCapabilityMaskT_v02)0x00000008) /**<  The service supports distance-based tracking  */
+#define QMI_LOC_MASK_AON_UPDATE_TBF_SUPPORTED_V02 ((qmiLocAonCapabilityMaskT_v02)0x00000010) /**<  The service supports changing TBF dynamically  */
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the clients to get always-on (AON) service settings.
+                      */
+typedef struct {
+
+  /* Mandatory */
+  /*  Transaction ID */
+  uint32_t transactionId;
+  /**<   Identifies the transaction. The same transaction ID
+       is returned in the QUERY_AON_CONFIG indication. */
+}qmiLocQueryAonConfigReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the clients to get always-on (AON) service settings.
+                      */
+typedef struct {
+
+  /* Mandatory */
+  /*  Always-On Config Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Query AON Config request.
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Optional */
+  /*  Transaction ID */
+  uint8_t transactionId_valid;  /**< Must be set to true if transactionId is being passed */
+  uint32_t transactionId;
+  /**<   Identifies the transaction. It is the same transaction
+       ID that was passed in the QUERY_AON_CONFIG request. */
+
+  /* Optional */
+  /*  Always-On Capability  */
+  uint8_t aonCapability_valid;  /**< Must be set to true if aonCapability is being passed */
+  qmiLocAonCapabilityMaskT_v02 aonCapability;
+  /**<   Always-on capabilities supported by the service. \n
+ Valid values: \n
+      - QMI_LOC_MASK_AON_AUTO_BATCHING_SUPPORTED (0x00000001) --  The service supports auto batching; the client can enable auto
+       batching by setting the distance parameter to 0 in the START_BATCHING request
+      - QMI_LOC_MASK_AON_DISTANCE_BASED_BATCHING_SUPPORTED (0x00000002) --  The service supports distance-based batching
+      - QMI_LOC_MASK_AON_TIME_BASED_BATCHING_SUPPORTED (0x00000004) --  The service supports time-based batching
+      - QMI_LOC_MASK_AON_DISTANCE_BASED_TRACKING_SUPPORTED (0x00000008) --  The service supports distance-based tracking
+      - QMI_LOC_MASK_AON_UPDATE_TBF_SUPPORTED (0x00000010) --  The service supports changing TBF dynamically */
+}qmiLocQueryAonConfigIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+typedef uint32_t qmiLocDeleteCommonDataMaskT_v02;
+#define QMI_LOC_DELETE_COMMON_MASK_POS_V02 ((qmiLocDeleteCommonDataMaskT_v02)0x00000001) /**<  Position estimate; common for all GNSS types  */
+#define QMI_LOC_DELETE_COMMON_MASK_TIME_V02 ((qmiLocDeleteCommonDataMaskT_v02)0x00000002) /**<  Reset all CLOCK_INFO mask  */
+#define QMI_LOC_DELETE_COMMON_MASK_UTC_V02 ((qmiLocDeleteCommonDataMaskT_v02)0x00000004) /**<  UTC estimate  */
+#define QMI_LOC_DELETE_COMMON_MASK_RTI_V02 ((qmiLocDeleteCommonDataMaskT_v02)0x00000008) /**<  RTI  */
+#define QMI_LOC_DELETE_COMMON_MASK_FREQ_BIAS_EST_V02 ((qmiLocDeleteCommonDataMaskT_v02)0x00000010) /**<  Frequency bias estimate; common for all GNSS types  */
+typedef uint32_t qmiLocDeleteSatelliteDataMaskT_v02;
+#define QMI_LOC_DELETE_DATA_MASK_EPHEMERIS_V02 ((qmiLocDeleteSatelliteDataMaskT_v02)0x00000001) /**<  Ephemeris  */
+#define QMI_LOC_DELETE_DATA_MASK_ALMANAC_V02 ((qmiLocDeleteSatelliteDataMaskT_v02)0x00000002) /**<  Almanac  */
+#define QMI_LOC_DELETE_DATA_MASK_SVHEALTH_V02 ((qmiLocDeleteSatelliteDataMaskT_v02)0x00000004) /**<  SV health  */
+#define QMI_LOC_DELETE_DATA_MASK_SVDIR_V02 ((qmiLocDeleteSatelliteDataMaskT_v02)0x00000008) /**<  SV direction  */
+#define QMI_LOC_DELETE_DATA_MASK_SVSTEER_V02 ((qmiLocDeleteSatelliteDataMaskT_v02)0x00000010) /**<  SV steer  */
+#define QMI_LOC_DELETE_DATA_MASK_ALM_CORR_V02 ((qmiLocDeleteSatelliteDataMaskT_v02)0x00000020) /**<  Almanac correction  */
+#define QMI_LOC_DELETE_DATA_MASK_BLACKLIST_V02 ((qmiLocDeleteSatelliteDataMaskT_v02)0x00000040) /**<  Blacklist SVs  */
+#define QMI_LOC_DELETE_DATA_MASK_SA_DATA_V02 ((qmiLocDeleteSatelliteDataMaskT_v02)0x00000080) /**<  Sensitivity assistance data  */
+#define QMI_LOC_DELETE_DATA_MASK_SV_NO_EXIST_V02 ((qmiLocDeleteSatelliteDataMaskT_v02)0x00000100) /**<  SV does not exist  */
+#define QMI_LOC_DELETE_DATA_MASK_IONO_V02 ((qmiLocDeleteSatelliteDataMaskT_v02)0x00000200) /**<  Ionosphere correction  */
+#define QMI_LOC_DELETE_DATA_MASK_TIME_V02 ((qmiLocDeleteSatelliteDataMaskT_v02)0x00000400) /**<  Reset satellite time  */
+typedef uint32_t qmiLocGNSSConstellMaskT_v02;
+#define QMI_LOC_SYSTEM_GPS_V02 ((qmiLocGNSSConstellMaskT_v02)0x00000001)
+#define QMI_LOC_SYSTEM_GLO_V02 ((qmiLocGNSSConstellMaskT_v02)0x00000002)
+#define QMI_LOC_SYSTEM_BDS_V02 ((qmiLocGNSSConstellMaskT_v02)0x00000004)
+#define QMI_LOC_SYSTEM_GAL_V02 ((qmiLocGNSSConstellMaskT_v02)0x00000008)
+#define QMI_LOC_SYSTEM_QZSS_V02 ((qmiLocGNSSConstellMaskT_v02)0x00000010)
+/** @addtogroup loc_qmi_aggregates
+    @{
+  */
+typedef struct {
+
+  qmiLocGNSSConstellMaskT_v02 system;
+  /**<   Indicates which satellite system's data is to be deleted.
+ The control point can delete multiple systems at a time.
+ Valid values: \n
+      - QMI_LOC_SYSTEM_GPS (0x00000001) --
+      - QMI_LOC_SYSTEM_GLO (0x00000002) --
+      - QMI_LOC_SYSTEM_BDS (0x00000004) --
+      - QMI_LOC_SYSTEM_GAL (0x00000008) --
+      - QMI_LOC_SYSTEM_QZSS (0x00000010) --
+ */
+
+  qmiLocDeleteSatelliteDataMaskT_v02 deleteSatelliteDataMask;
+  /**<   Requested bitmask of data to be deleted for the specified satellite system. \n
+ Valid values: \n
+      - QMI_LOC_DELETE_DATA_MASK_EPHEMERIS (0x00000001) --  Ephemeris
+      - QMI_LOC_DELETE_DATA_MASK_ALMANAC (0x00000002) --  Almanac
+      - QMI_LOC_DELETE_DATA_MASK_SVHEALTH (0x00000004) --  SV health
+      - QMI_LOC_DELETE_DATA_MASK_SVDIR (0x00000008) --  SV direction
+      - QMI_LOC_DELETE_DATA_MASK_SVSTEER (0x00000010) --  SV steer
+      - QMI_LOC_DELETE_DATA_MASK_ALM_CORR (0x00000020) --  Almanac correction
+      - QMI_LOC_DELETE_DATA_MASK_BLACKLIST (0x00000040) --  Blacklist SVs
+      - QMI_LOC_DELETE_DATA_MASK_SA_DATA (0x00000080) --  Sensitivity assistance data
+      - QMI_LOC_DELETE_DATA_MASK_SV_NO_EXIST (0x00000100) --  SV does not exist
+      - QMI_LOC_DELETE_DATA_MASK_IONO (0x00000200) --  Ionosphere correction
+      - QMI_LOC_DELETE_DATA_MASK_TIME (0x00000400) --  Reset satellite time
+ */
+}qmiLocDeleteSatelliteDataStructT_v02;  /* Type */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Deletes the location engine
+                    service data from memory. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Reset All */
+  uint8_t deleteAllFlag;
+  /**<   Indicates whether all GNSS service data is to be deleted.
+       Values:
+       0x01 (TRUE)  -- All constellations' service data is to be reset;
+                       if this flag is set, all the other information
+                       contained in the optional fields for this
+                       message are ignored
+       0x00 (FALSE) -- The optional fields in the message are to be
+                       used to determine which data is to be deleted
+  */
+
+  /* Optional */
+  /*  Requested Bitmask of Clock Info Data to be Deleted */
+  uint8_t deleteClockInfoMask_valid;  /**< Must be set to true if deleteClockInfoMask is being passed */
+  qmiLocDeleteClockInfoMaskT_v02 deleteClockInfoMask;
+  /**<   Mask for the clock information service data that is to be deleted.
+ If QMI_LOC_DELETE_DATA_MASK_TIME is set in deleteServiceDataMask,
+ deleteClockInfoMask will be ignored.
+ Valid values: \n
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_TIME_EST (0x00000001) --  Mask to delete time estimate from clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_FREQ_EST (0x00000002) --  Mask to delete frequency estimate from clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_WEEK_NUMBER (0x00000004) --  Mask to delete week number from clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_RTC_TIME (0x00000008) --  Mask to delete RTC time from clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_TIME_TRANSFER (0x00000010) --  Mask to delete time transfer from clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_GPSTIME_EST (0x00000020) --  Mask to delete GPS time estimate from clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_GLOTIME_EST (0x00000040) --  Mask to delete GLONASS time estimate from clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_GLODAY_NUMBER (0x00000080) --  Mask to delete GLONASS day number from clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_GLO4YEAR_NUMBER (0x00000100) --  Mask to delete GLONASS four year number from clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_GLO_RF_GRP_DELAY (0x00000200) --  Mask to delete GLONASS RF GRP delay from clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_DISABLE_TT (0x00000400) --  Mask to delete disable TT from clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_GG_LEAPSEC (0x00000800) --  Mask to delete a BDS time estimate from the clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_GG_GGTB (0x00001000) --  Mask to delete a BDS time estimate from the clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_BDSTIME_EST (0x00002000) --  Mask to delete a BDS time estimate from the clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_GB_GBTB (0x00004000) --  Mask to delete Glonass-to-BDS time bias-related information from the
+      clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_BG_BGTB (0x00008000) --  Mask to delete BDS-to-GLONASS time bias-related information from the
+       clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_BDSWEEK_NUMBER (0x00010000) --  Mask to delete the BDS week number from the clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_BDS_RF_GRP_DELAY (0x00020000) --  Mask to delete the BDS RF GRP delay from the clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_GALTIME_EST (0x00040000) --  Mask to delete a GAL time estimate from the clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_GALTOGPS_TB (0x00080000) --  Mask to delete GAL-to-GPS time bias-related information from the
+      clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_GALTOGLO_TB (0x00100000) --  Mask to delete GAL-to-GLO time bias-related information from the
+      clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_GALTOBDS_TB (0x00200000) --  Mask to delete GAL-to-BDS time bias-related information from the
+      clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_GALWEEK_NUMBER (0x00800000) --  Mask to delete the GAL week number from the clock information
+      - QMI_LOC_MASK_DELETE_CLOCK_INFO_GAL_RF_GRP_DELAY (0x01000000) --  Mask to delete the GAL RF GRP delay from the clock information
+ */
+
+  /* Optional */
+  /*  Requested Bitmask of Cell DB Data to be Deleted */
+  uint8_t deleteCellDbDataMask_valid;  /**< Must be set to true if deleteCellDbDataMask is being passed */
+  qmiLocDeleteCelldbDataMaskT_v02 deleteCellDbDataMask;
+  /**<   Mask for the cell database service data that is to be deleted;
+ common for all GNSS types.
+ Valid values: \n
+      - QMI_LOC_MASK_DELETE_CELLDB_POS (0x00000001) --  Mask to delete cell database position
+      - QMI_LOC_MASK_DELETE_CELLDB_LATEST_GPS_POS (0x00000002) --  Mask to delete cell database latest GPS position
+      - QMI_LOC_MASK_DELETE_CELLDB_OTA_POS (0x00000004) --  Mask to delete cell database OTA position
+      - QMI_LOC_MASK_DELETE_CELLDB_EXT_REF_POS (0x00000008) --  Mask to delete cell database external reference position
+      - QMI_LOC_MASK_DELETE_CELLDB_TIMETAG (0x00000010) --  Mask to delete cell database time tag
+      - QMI_LOC_MASK_DELETE_CELLDB_CELLID (0x00000020) --  Mask to delete cell database cell ID
+      - QMI_LOC_MASK_DELETE_CELLDB_CACHED_CELLID (0x00000040) --  Mask to delete cell database cached cell ID
+      - QMI_LOC_MASK_DELETE_CELLDB_LAST_SRV_CELL (0x00000080) --  Mask to delete cell database last service cell
+      - QMI_LOC_MASK_DELETE_CELLDB_CUR_SRV_CELL (0x00000100) --  Mask to delete cell database current service cell
+      - QMI_LOC_MASK_DELETE_CELLDB_NEIGHBOR_INFO (0x00000200) --  Mask to delete cell database neighbor information
+ */
+
+  /* Optional */
+  /*  Requested Bitmask of Common Data to be Deleted */
+  uint8_t deleteCommonDataMask_valid;  /**< Must be set to true if deleteCommonDataMask is being passed */
+  qmiLocDeleteCommonDataMaskT_v02 deleteCommonDataMask;
+  /**<   Mask for the common service data that is to be deleted.
+ Valid values: \n
+      - QMI_LOC_DELETE_COMMON_MASK_POS (0x00000001) --  Position estimate; common for all GNSS types
+      - QMI_LOC_DELETE_COMMON_MASK_TIME (0x00000002) --  Reset all CLOCK_INFO mask
+      - QMI_LOC_DELETE_COMMON_MASK_UTC (0x00000004) --  UTC estimate
+      - QMI_LOC_DELETE_COMMON_MASK_RTI (0x00000008) --  RTI
+      - QMI_LOC_DELETE_COMMON_MASK_FREQ_BIAS_EST (0x00000010) --  Frequency bias estimate; common for all GNSS types
+ */
+
+  /* Optional */
+  /*  GNSS Service Data to be Deleted */
+  uint8_t deleteSatelliteData_valid;  /**< Must be set to true if deleteSatelliteData is being passed */
+  qmiLocDeleteSatelliteDataStructT_v02 deleteSatelliteData;
+  /**<   Request to delete the GNSS service data.*/
+}qmiLocDeleteGNSSServiceDataReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Deletes the location engine
+                    service data from memory. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Delete GNSS Service Data Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Delete Assist Data request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+}qmiLocDeleteGNSSServiceDataIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCXTRADATAFORMATENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_XTRA_DATA_V02 = 0, /**<  Default is QCOM-XTRA format.  */
+  QMILOCXTRADATAFORMATENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocXtraDataFormatEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Injects XTRA data. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Total Size */
+  uint32_t totalSize;
+  /**<   Total size of the XTRA data to be injected. \n
+        - Units: Bytes */
+
+  /* Mandatory */
+  /*  Total Parts */
+  uint16_t totalParts;
+  /**<   Total number of parts into which the XTRA data is divided. */
+
+  /* Mandatory */
+  /*  Part Number */
+  uint16_t partNum;
+  /**<   Number of the current XTRA data part; starts at 1. */
+
+  /* Mandatory */
+  /*  Data */
+  uint32_t partData_len;  /**< Must be set to # of elements in partData */
+  uint8_t partData[QMI_LOC_MAX_XTRA_PART_LEN_V02];
+  /**<   XTRA data. \n
+         - Type: Array of bytes \n
+         - Maximum length of the array: 1024
+    */
+
+  /* Optional */
+  /*  Format Type */
+  uint8_t formatType_valid;  /**< Must be set to true if formatType is being passed */
+  qmiLocXtraDataFormatEnumT_v02 formatType;
+  /**<   XTRA data format. \n
+ Valid values: \n
+      - eQMI_LOC_XTRA_DATA (0) --  Default is QCOM-XTRA format.
+ */
+}qmiLocInjectXtraDataReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Injects XTRA data. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Data Injection Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Data Injection request.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Optional */
+  /*  Part Number */
+  uint8_t partNum_valid;  /**< Must be set to true if partNum is being passed */
+  uint16_t partNum;
+  /**<   Number of the XTRA data part for which this indication
+      is sent; starts at 1. */
+}qmiLocInjectXtraDataIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to inject PCID which is used by XTRA service. */
+typedef struct {
+
+  /* Mandatory */
+  /*  XTRA PCID */
+  uint64_t xtraPcid;
+  /**<   - Type: uint64 \n */
+}qmiLocInjectXtraPcidReqMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to inject PCID which is used by XTRA service. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Inject XTRA PCID Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the inject XTRA PCID.
+
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure  */
+}qmiLocInjectXtraPcidIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Request Message; Used by the control point to query QMI_LOC service supported features. */
+typedef struct {
+  /* This element is a placeholder to prevent the declaration of
+     an empty struct.  DO NOT USE THIS FIELD UNDER ANY CIRCUMSTANCE */
+  char __placeholder;
+}qmiLocGetSupportedFeatureReqMsgT_v02;
+
+  /* Message */
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_enums
+    @{
+  */
+typedef enum {
+  QMILOCSUPPORTEDFEATUREENUMT_MIN_ENUM_VAL_V02 = -2147483647, /**< To force a 32 bit signed enum.  Do not change or use*/
+  eQMI_LOC_SUPPORTED_FEATURE_ODCPI_2_V02 = 0, /**<  Support ODCPI version 2 feature  */
+  eQMI_LOC_SUPPORTED_FEATURE_WIFI_AP_DATA_INJECT_2_V02 = 1, /**<  Support Wifi AP data inject version 2 feature  */
+  QMILOCSUPPORTEDFEATUREENUMT_MAX_ENUM_VAL_V02 = 2147483647 /**< To force a 32 bit signed enum.  Do not change or use*/
+}qmiLocSupportedFeatureEnumT_v02;
+/**
+    @}
+  */
+
+/** @addtogroup loc_qmi_messages
+    @{
+  */
+/** Indication Message; Used by the control point to query QMI_LOC service supported features. */
+typedef struct {
+
+  /* Mandatory */
+  /*  Supported Feature Status */
+  qmiLocStatusEnumT_v02 status;
+  /**<   Status of the Query Supported Feature request.
+ Valid values: \n
+      - eQMI_LOC_SUCCESS (0) --  Request was completed successfully \n
+      - eQMI_LOC_GENERAL_FAILURE (1) --  Request failed because of a general failure \n
+      - eQMI_LOC_UNSUPPORTED (2) --  Request failed because it is not supported \n
+      - eQMI_LOC_INVALID_PARAMETER (3) --  Request failed because it contained invalid parameters \n
+      - eQMI_LOC_ENGINE_BUSY (4) --  Request failed because the engine is busy \n
+      - eQMI_LOC_PHONE_OFFLINE (5) --  Request failed because the phone is offline \n
+      - eQMI_LOC_TIMEOUT (6) --  Request failed because it timed out \n
+      - eQMI_LOC_CONFIG_NOT_SUPPORTED (7) --  Request failed because an undefined configuration was requested \n
+      - eQMI_LOC_INSUFFICIENT_MEMORY (8) --  Request failed because the engine could not allocate sufficient memory for the request \n
+      - eQMI_LOC_MAX_GEOFENCE_PROGRAMMED (9) --  Request failed because the maximum number of Geofences are already programmed \n
+      - eQMI_LOC_XTRA_VERSION_CHECK_FAILURE (10) --  Location service failed because of an XTRA version-based file format check failure
+ */
+
+  /* Mandatory */
+  /*   Supported feature */
+  uint32_t feature_len;  /**< Must be set to # of elements in feature */
+  uint8_t feature[QMI_LOC_SUPPORTED_FEATURE_LENGTH_V02];
+  /**<   This field describes which feature are supported in the running
+       QMI_LOC service. The array of unit8 is the bitmask where each bit
+       represents a feature enum. Bit 0 represents feature enum ID 0,
+       bit 1 represents feature enum ID 1, etc.
+       For example, if QMI_LOC spports feature enum 0,1,2,8,
+       feature_len is 2,
+       feature array is [7,1]
+       - Type: Array of uint8
+       - Maximum array length: 100
+  */
+}qmiLocGetSupportedFeatureIndMsgT_v02;  /* Message */
+/**
+    @}
+  */
+
+/* Conditional compilation tags for message removal */
+//#define REMOVE_QMI_LOC_ADD_CIRCULAR_GEOFENCE_V02
+//#define REMOVE_QMI_LOC_ADD_GEOFENCE_CONTEXT_V02
+//#define REMOVE_QMI_LOC_DELETE_ASSIST_DATA_V02
+//#define REMOVE_QMI_LOC_DELETE_GEOFENCE_V02
+//#define REMOVE_QMI_LOC_DELETE_GEOFENCE_CONTEXT_V02
+//#define REMOVE_QMI_LOC_DELETE_GNSS_SERVICE_DATA_V02
+//#define REMOVE_QMI_LOC_DELETE_SUPL_CERTIFICATE_V02
+//#define REMOVE_QMI_LOC_EDIT_GEOFENCE_V02
+//#define REMOVE_QMI_LOC_EVENT_BATCHING_STATUS_V02
+//#define REMOVE_QMI_LOC_EVENT_BATCH_FULL_NOTIFICATION_V02
+//#define REMOVE_QMI_LOC_EVENT_DBT_POSITION_REPORT_V02
+//#define REMOVE_QMI_LOC_EVENT_DBT_SESSION_STATUS_V02
+//#define REMOVE_QMI_LOC_EVENT_ENGINE_STATE_V02
+//#define REMOVE_QMI_LOC_EVENT_FIX_SESSION_STATE_V02
+//#define REMOVE_QMI_LOC_EVENT_GDT_DOWNLOAD_BEGIN_REQ_V02
+//#define REMOVE_QMI_LOC_EVENT_GDT_DOWNLOAD_END_REQ_V02
+//#define REMOVE_QMI_LOC_EVENT_GDT_RECEIVE_DONE_V02
+//#define REMOVE_QMI_LOC_EVENT_GDT_UPLOAD_BEGIN_STATUS_REQ_V02
+//#define REMOVE_QMI_LOC_EVENT_GDT_UPLOAD_END_REQ_V02
+//#define REMOVE_QMI_LOC_EVENT_GEOFENCE_BATCHED_BREACH_NOTIFICATION_V02
+//#define REMOVE_QMI_LOC_EVENT_GEOFENCE_BATCHED_DWELL_NOTIFICATION_V02
+//#define REMOVE_QMI_LOC_EVENT_GEOFENCE_BREACH_NOTIFICATION_V02
+//#define REMOVE_QMI_LOC_EVENT_GEOFENCE_GEN_ALERT_V02
+//#define REMOVE_QMI_LOC_EVENT_GEOFENCE_PROXIMITY_NOTIFICATION_V02
+//#define REMOVE_QMI_LOC_EVENT_GET_TIME_ZONE_INFO_V02
+//#define REMOVE_QMI_LOC_EVENT_GNSS_MEASUREMENT_REPORT_IND_V02
+//#define REMOVE_QMI_LOC_EVENT_GNSS_SV_INFO_V02
+//#define REMOVE_QMI_LOC_EVENT_INJECT_POSITION_REQ_V02
+//#define REMOVE_QMI_LOC_EVENT_INJECT_PREDICTED_ORBITS_REQ_V02
+//#define REMOVE_QMI_LOC_EVENT_INJECT_TIME_REQ_V02
+//#define REMOVE_QMI_LOC_EVENT_INJECT_WIFI_AP_DATA_REQ_V02
+//#define REMOVE_QMI_LOC_EVENT_LIVE_BATCHED_POSITION_REPORT_V02
+//#define REMOVE_QMI_LOC_EVENT_LOCATION_SERVER_CONNECTION_REQ_V02
+//#define REMOVE_QMI_LOC_EVENT_MOTION_DATA_CONTROL_V02
+//#define REMOVE_QMI_LOC_EVENT_NI_GEOFENCE_NOTIFICATION_V02
+//#define REMOVE_QMI_LOC_EVENT_NI_NOTIFY_VERIFY_REQ_V02
+//#define REMOVE_QMI_LOC_EVENT_NMEA_V02
+//#define REMOVE_QMI_LOC_EVENT_PEDOMETER_CONTROL_V02
+//#define REMOVE_QMI_LOC_EVENT_POSITION_REPORT_V02
+//#define REMOVE_QMI_LOC_EVENT_SENSOR_STREAMING_READY_STATUS_V02
+//#define REMOVE_QMI_LOC_EVENT_SET_SPI_STREAMING_REPORT_V02
+//#define REMOVE_QMI_LOC_EVENT_SV_POLYNOMIAL_REPORT_IND_V02
+//#define REMOVE_QMI_LOC_EVENT_TIME_SYNC_REQ_V02
+//#define REMOVE_QMI_LOC_EVENT_VEHICLE_DATA_READY_STATUS_V02
+//#define REMOVE_QMI_LOC_EVENT_WIFI_REQ_V02
+//#define REMOVE_QMI_LOC_GDT_DOWNLOAD_BEGIN_STATUS_V02
+//#define REMOVE_QMI_LOC_GDT_DOWNLOAD_END_STATUS_V02
+//#define REMOVE_QMI_LOC_GDT_DOWNLOAD_READY_STATUS_V02
+//#define REMOVE_QMI_LOC_GDT_RECEIVE_DONE_STATUS_V02
+//#define REMOVE_QMI_LOC_GDT_UPLOAD_BEGIN_STATUS_V02
+//#define REMOVE_QMI_LOC_GDT_UPLOAD_END_V02
+//#define REMOVE_QMI_LOC_GET_AVAILABLE_WWAN_POSITION_V02
+//#define REMOVE_QMI_LOC_GET_BATCH_SIZE_V02
+//#define REMOVE_QMI_LOC_GET_BEST_AVAILABLE_POSITION_V02
+//#define REMOVE_QMI_LOC_GET_CRADLE_MOUNT_CONFIG_V02
+//#define REMOVE_QMI_LOC_GET_ENGINE_LOCK_V02
+//#define REMOVE_QMI_LOC_GET_EXTERNAL_POWER_CONFIG_V02
+//#define REMOVE_QMI_LOC_GET_FIX_CRITERIA_V02
+//#define REMOVE_QMI_LOC_GET_GEOFENCE_ENGINE_CONFIG_V02
+//#define REMOVE_QMI_LOC_GET_LOW_POWER_MODE_V02
+//#define REMOVE_QMI_LOC_GET_NI_GEOFENCE_ID_LIST_V02
+//#define REMOVE_QMI_LOC_GET_NMEA_TYPES_V02
+//#define REMOVE_QMI_LOC_GET_OPERATION_MODE_V02
+//#define REMOVE_QMI_LOC_GET_POSITION_ENGINE_CONFIG_PARAMETERS_V02
+//#define REMOVE_QMI_LOC_GET_PREDICTED_ORBITS_DATA_SOURCE_V02
+//#define REMOVE_QMI_LOC_GET_PREDICTED_ORBITS_DATA_VALIDITY_V02
+//#define REMOVE_QMI_LOC_GET_PROTOCOL_CONFIG_PARAMETERS_V02
+//#define REMOVE_QMI_LOC_GET_REGISTERED_EVENTS_V02
+//#define REMOVE_QMI_LOC_GET_SBAS_CONFIG_V02
+//#define REMOVE_QMI_LOC_GET_SENSOR_CONTROL_CONFIG_V02
+//#define REMOVE_QMI_LOC_GET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_V02
+//#define REMOVE_QMI_LOC_GET_SENSOR_PROPERTIES_V02
+//#define REMOVE_QMI_LOC_GET_SERVER_V02
+//#define REMOVE_QMI_LOC_GET_SERVICE_REVISION_V02
+//#define REMOVE_QMI_LOC_GET_SUPPORTED_FEATURE_V02
+//#define REMOVE_QMI_LOC_GET_SUPPORTED_FIELDS_V02
+//#define REMOVE_QMI_LOC_GET_SUPPORTED_MSGS_V02
+//#define REMOVE_QMI_LOC_GET_XTRA_T_SESSION_CONTROL_V02
+//#define REMOVE_QMI_LOC_GTP_AP_STATUS_V02
+//#define REMOVE_QMI_LOC_INFORM_CLIENT_REVISION_V02
+//#define REMOVE_QMI_LOC_INFORM_LOCATION_SERVER_CONN_STATUS_V02
+//#define REMOVE_QMI_LOC_INFORM_NI_USER_RESPONSE_V02
+//#define REMOVE_QMI_LOC_INJECT_APCACHE_DATA_V02
+//#define REMOVE_QMI_LOC_INJECT_APDONOTCACHE_DATA_V02
+//#define REMOVE_QMI_LOC_INJECT_GSM_CELL_INFO_V02
+//#define REMOVE_QMI_LOC_INJECT_GTP_CLIENT_DOWNLOADED_DATA_V02
+//#define REMOVE_QMI_LOC_INJECT_MOTION_DATA_V02
+//#define REMOVE_QMI_LOC_INJECT_NETWORK_INITIATED_MESSAGE_V02
+//#define REMOVE_QMI_LOC_INJECT_POSITION_V02
+//#define REMOVE_QMI_LOC_INJECT_PREDICTED_ORBITS_DATA_V02
+//#define REMOVE_QMI_LOC_INJECT_SENSOR_DATA_V02
+//#define REMOVE_QMI_LOC_INJECT_SUBSCRIBER_ID_V02
+//#define REMOVE_QMI_LOC_INJECT_SUPL_CERTIFICATE_V02
+//#define REMOVE_QMI_LOC_INJECT_TDSCDMA_CELL_INFO_V02
+//#define REMOVE_QMI_LOC_INJECT_TIME_SYNC_DATA_V02
+//#define REMOVE_QMI_LOC_INJECT_TIME_ZONE_INFO_V02
+//#define REMOVE_QMI_LOC_INJECT_UTC_TIME_V02
+//#define REMOVE_QMI_LOC_INJECT_VEHICLE_SENSOR_DATA_V02
+//#define REMOVE_QMI_LOC_INJECT_WCDMA_CELL_INFO_V02
+//#define REMOVE_QMI_LOC_INJECT_WIFI_AP_DATA_V02
+//#define REMOVE_QMI_LOC_INJECT_WIFI_POSITION_V02
+//#define REMOVE_QMI_LOC_INJECT_XTRA_DATA_V02
+//#define REMOVE_QMI_LOC_INJECT_XTRA_PCID_V02
+//#define REMOVE_QMI_LOC_NOTIFY_WIFI_ATTACHMENT_STATUS_V02
+//#define REMOVE_QMI_LOC_NOTIFY_WIFI_ENABLED_STATUS_V02
+//#define REMOVE_QMI_LOC_NOTIFY_WIFI_STATUS_V02
+//#define REMOVE_QMI_LOC_PEDOMETER_REPORT_V02
+//#define REMOVE_QMI_LOC_QUERY_AON_CONFIG_V02
+//#define REMOVE_QMI_LOC_QUERY_GEOFENCE_V02
+//#define REMOVE_QMI_LOC_READ_FROM_BATCH_V02
+//#define REMOVE_QMI_LOC_REG_EVENTS_V02
+//#define REMOVE_QMI_LOC_RELEASE_BATCH_V02
+//#define REMOVE_QMI_LOC_SECURE_GET_AVAILABLE_POSITION_V02
+//#define REMOVE_QMI_LOC_SET_CRADLE_MOUNT_CONFIG_V02
+//#define REMOVE_QMI_LOC_SET_ENGINE_LOCK_V02
+//#define REMOVE_QMI_LOC_SET_EXTERNAL_POWER_CONFIG_V02
+//#define REMOVE_QMI_LOC_SET_GEOFENCE_ENGINE_CONFIG_V02
+//#define REMOVE_QMI_LOC_SET_GEOFENCE_ENGINE_CONTEXT_V02
+//#define REMOVE_QMI_LOC_SET_GNSS_CONSTELL_REPORT_CONFIG_V02
+//#define REMOVE_QMI_LOC_SET_LOW_POWER_MODE_V02
+//#define REMOVE_QMI_LOC_SET_NMEA_TYPES_V02
+//#define REMOVE_QMI_LOC_SET_OPERATION_MODE_V02
+//#define REMOVE_QMI_LOC_SET_POSITION_ENGINE_CONFIG_PARAMETERS_V02
+//#define REMOVE_QMI_LOC_SET_PREMIUM_SERVICES_CONFIG_V02
+//#define REMOVE_QMI_LOC_SET_PROTOCOL_CONFIG_PARAMETERS_V02
+//#define REMOVE_QMI_LOC_SET_SBAS_CONFIG_V02
+//#define REMOVE_QMI_LOC_SET_SENSOR_CONTROL_CONFIG_V02
+//#define REMOVE_QMI_LOC_SET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_V02
+//#define REMOVE_QMI_LOC_SET_SENSOR_PROPERTIES_V02
+//#define REMOVE_QMI_LOC_SET_SERVER_V02
+//#define REMOVE_QMI_LOC_SET_SPI_STATUS_V02
+//#define REMOVE_QMI_LOC_SET_XTRA_T_SESSION_CONTROL_V02
+//#define REMOVE_QMI_LOC_SET_XTRA_VERSION_CHECK_V02
+//#define REMOVE_QMI_LOC_START_V02
+//#define REMOVE_QMI_LOC_START_BATCHING_V02
+//#define REMOVE_QMI_LOC_START_DBT_V02
+//#define REMOVE_QMI_LOC_STOP_V02
+//#define REMOVE_QMI_LOC_STOP_BATCHING_V02
+//#define REMOVE_QMI_LOC_STOP_DBT_V02
+//#define REMOVE_QMI_LOC_WWAN_OUT_OF_SERVICE_NOTIFICATION_V02
+
+/*Service Message Definition*/
+/** @addtogroup loc_qmi_msg_ids
+    @{
+  */
+#define QMI_LOC_GET_SUPPORTED_MSGS_REQ_V02 0x001E
+#define QMI_LOC_GET_SUPPORTED_MSGS_RESP_V02 0x001E
+#define QMI_LOC_GET_SUPPORTED_FIELDS_REQ_V02 0x001F
+#define QMI_LOC_GET_SUPPORTED_FIELDS_RESP_V02 0x001F
+#define QMI_LOC_INFORM_CLIENT_REVISION_REQ_V02 0x0020
+#define QMI_LOC_INFORM_CLIENT_REVISION_RESP_V02 0x0020
+#define QMI_LOC_REG_EVENTS_REQ_V02 0x0021
+#define QMI_LOC_REG_EVENTS_RESP_V02 0x0021
+#define QMI_LOC_START_REQ_V02 0x0022
+#define QMI_LOC_START_RESP_V02 0x0022
+#define QMI_LOC_STOP_REQ_V02 0x0023
+#define QMI_LOC_STOP_RESP_V02 0x0023
+#define QMI_LOC_EVENT_POSITION_REPORT_IND_V02 0x0024
+#define QMI_LOC_EVENT_GNSS_SV_INFO_IND_V02 0x0025
+#define QMI_LOC_EVENT_NMEA_IND_V02 0x0026
+#define QMI_LOC_EVENT_NI_NOTIFY_VERIFY_REQ_IND_V02 0x0027
+#define QMI_LOC_EVENT_INJECT_TIME_REQ_IND_V02 0x0028
+#define QMI_LOC_EVENT_INJECT_PREDICTED_ORBITS_REQ_IND_V02 0x0029
+#define QMI_LOC_EVENT_INJECT_POSITION_REQ_IND_V02 0x002A
+#define QMI_LOC_EVENT_ENGINE_STATE_IND_V02 0x002B
+#define QMI_LOC_EVENT_FIX_SESSION_STATE_IND_V02 0x002C
+#define QMI_LOC_EVENT_WIFI_REQ_IND_V02 0x002D
+#define QMI_LOC_EVENT_SENSOR_STREAMING_READY_STATUS_IND_V02 0x002E
+#define QMI_LOC_EVENT_TIME_SYNC_REQ_IND_V02 0x002F
+#define QMI_LOC_EVENT_SET_SPI_STREAMING_REPORT_IND_V02 0x0030
+#define QMI_LOC_EVENT_LOCATION_SERVER_CONNECTION_REQ_IND_V02 0x0031
+#define QMI_LOC_GET_SERVICE_REVISION_REQ_V02 0x0032
+#define QMI_LOC_GET_SERVICE_REVISION_RESP_V02 0x0032
+#define QMI_LOC_GET_SERVICE_REVISION_IND_V02 0x0032
+#define QMI_LOC_GET_FIX_CRITERIA_REQ_V02 0x0033
+#define QMI_LOC_GET_FIX_CRITERIA_RESP_V02 0x0033
+#define QMI_LOC_GET_FIX_CRITERIA_IND_V02 0x0033
+#define QMI_LOC_NI_USER_RESPONSE_REQ_V02 0x0034
+#define QMI_LOC_NI_USER_RESPONSE_RESP_V02 0x0034
+#define QMI_LOC_NI_USER_RESPONSE_IND_V02 0x0034
+#define QMI_LOC_INJECT_PREDICTED_ORBITS_DATA_REQ_V02 0x0035
+#define QMI_LOC_INJECT_PREDICTED_ORBITS_DATA_RESP_V02 0x0035
+#define QMI_LOC_INJECT_PREDICTED_ORBITS_DATA_IND_V02 0x0035
+#define QMI_LOC_GET_PREDICTED_ORBITS_DATA_SOURCE_REQ_V02 0x0036
+#define QMI_LOC_GET_PREDICTED_ORBITS_DATA_SOURCE_RESP_V02 0x0036
+#define QMI_LOC_GET_PREDICTED_ORBITS_DATA_SOURCE_IND_V02 0x0036
+#define QMI_LOC_GET_PREDICTED_ORBITS_DATA_VALIDITY_REQ_V02 0x0037
+#define QMI_LOC_GET_PREDICTED_ORBITS_DATA_VALIDITY_RESP_V02 0x0037
+#define QMI_LOC_GET_PREDICTED_ORBITS_DATA_VALIDITY_IND_V02 0x0037
+#define QMI_LOC_INJECT_UTC_TIME_REQ_V02 0x0038
+#define QMI_LOC_INJECT_UTC_TIME_RESP_V02 0x0038
+#define QMI_LOC_INJECT_UTC_TIME_IND_V02 0x0038
+#define QMI_LOC_INJECT_POSITION_REQ_V02 0x0039
+#define QMI_LOC_INJECT_POSITION_RESP_V02 0x0039
+#define QMI_LOC_INJECT_POSITION_IND_V02 0x0039
+#define QMI_LOC_SET_ENGINE_LOCK_REQ_V02 0x003A
+#define QMI_LOC_SET_ENGINE_LOCK_RESP_V02 0x003A
+#define QMI_LOC_SET_ENGINE_LOCK_IND_V02 0x003A
+#define QMI_LOC_GET_ENGINE_LOCK_REQ_V02 0x003B
+#define QMI_LOC_GET_ENGINE_LOCK_RESP_V02 0x003B
+#define QMI_LOC_GET_ENGINE_LOCK_IND_V02 0x003B
+#define QMI_LOC_SET_SBAS_CONFIG_REQ_V02 0x003C
+#define QMI_LOC_SET_SBAS_CONFIG_RESP_V02 0x003C
+#define QMI_LOC_SET_SBAS_CONFIG_IND_V02 0x003C
+#define QMI_LOC_GET_SBAS_CONFIG_REQ_V02 0x003D
+#define QMI_LOC_GET_SBAS_CONFIG_RESP_V02 0x003D
+#define QMI_LOC_GET_SBAS_CONFIG_IND_V02 0x003D
+#define QMI_LOC_SET_NMEA_TYPES_REQ_V02 0x003E
+#define QMI_LOC_SET_NMEA_TYPES_RESP_V02 0x003E
+#define QMI_LOC_SET_NMEA_TYPES_IND_V02 0x003E
+#define QMI_LOC_GET_NMEA_TYPES_REQ_V02 0x003F
+#define QMI_LOC_GET_NMEA_TYPES_RESP_V02 0x003F
+#define QMI_LOC_GET_NMEA_TYPES_IND_V02 0x003F
+#define QMI_LOC_SET_LOW_POWER_MODE_REQ_V02 0x0040
+#define QMI_LOC_SET_LOW_POWER_MODE_RESP_V02 0x0040
+#define QMI_LOC_SET_LOW_POWER_MODE_IND_V02 0x0040
+#define QMI_LOC_GET_LOW_POWER_MODE_REQ_V02 0x0041
+#define QMI_LOC_GET_LOW_POWER_MODE_RESP_V02 0x0041
+#define QMI_LOC_GET_LOW_POWER_MODE_IND_V02 0x0041
+#define QMI_LOC_SET_SERVER_REQ_V02 0x0042
+#define QMI_LOC_SET_SERVER_RESP_V02 0x0042
+#define QMI_LOC_SET_SERVER_IND_V02 0x0042
+#define QMI_LOC_GET_SERVER_REQ_V02 0x0043
+#define QMI_LOC_GET_SERVER_RESP_V02 0x0043
+#define QMI_LOC_GET_SERVER_IND_V02 0x0043
+#define QMI_LOC_DELETE_ASSIST_DATA_REQ_V02 0x0044
+#define QMI_LOC_DELETE_ASSIST_DATA_RESP_V02 0x0044
+#define QMI_LOC_DELETE_ASSIST_DATA_IND_V02 0x0044
+#define QMI_LOC_SET_XTRA_T_SESSION_CONTROL_REQ_V02 0x0045
+#define QMI_LOC_SET_XTRA_T_SESSION_CONTROL_RESP_V02 0x0045
+#define QMI_LOC_SET_XTRA_T_SESSION_CONTROL_IND_V02 0x0045
+#define QMI_LOC_GET_XTRA_T_SESSION_CONTROL_REQ_V02 0x0046
+#define QMI_LOC_GET_XTRA_T_SESSION_CONTROL_RESP_V02 0x0046
+#define QMI_LOC_GET_XTRA_T_SESSION_CONTROL_IND_V02 0x0046
+#define QMI_LOC_INJECT_WIFI_POSITION_REQ_V02 0x0047
+#define QMI_LOC_INJECT_WIFI_POSITION_RESP_V02 0x0047
+#define QMI_LOC_INJECT_WIFI_POSITION_IND_V02 0x0047
+#define QMI_LOC_NOTIFY_WIFI_STATUS_REQ_V02 0x0048
+#define QMI_LOC_NOTIFY_WIFI_STATUS_RESP_V02 0x0048
+#define QMI_LOC_NOTIFY_WIFI_STATUS_IND_V02 0x0048
+#define QMI_LOC_GET_REGISTERED_EVENTS_REQ_V02 0x0049
+#define QMI_LOC_GET_REGISTERED_EVENTS_RESP_V02 0x0049
+#define QMI_LOC_GET_REGISTERED_EVENTS_IND_V02 0x0049
+#define QMI_LOC_SET_OPERATION_MODE_REQ_V02 0x004A
+#define QMI_LOC_SET_OPERATION_MODE_RESP_V02 0x004A
+#define QMI_LOC_SET_OPERATION_MODE_IND_V02 0x004A
+#define QMI_LOC_GET_OPERATION_MODE_REQ_V02 0x004B
+#define QMI_LOC_GET_OPERATION_MODE_RESP_V02 0x004B
+#define QMI_LOC_GET_OPERATION_MODE_IND_V02 0x004B
+#define QMI_LOC_SET_SPI_STATUS_REQ_V02 0x004C
+#define QMI_LOC_SET_SPI_STATUS_RESP_V02 0x004C
+#define QMI_LOC_SET_SPI_STATUS_IND_V02 0x004C
+#define QMI_LOC_INJECT_SENSOR_DATA_REQ_V02 0x004D
+#define QMI_LOC_INJECT_SENSOR_DATA_RESP_V02 0x004D
+#define QMI_LOC_INJECT_SENSOR_DATA_IND_V02 0x004D
+#define QMI_LOC_INJECT_TIME_SYNC_DATA_REQ_V02 0x004E
+#define QMI_LOC_INJECT_TIME_SYNC_DATA_RESP_V02 0x004E
+#define QMI_LOC_INJECT_TIME_SYNC_DATA_IND_V02 0x004E
+#define QMI_LOC_SET_CRADLE_MOUNT_CONFIG_REQ_V02 0x004F
+#define QMI_LOC_SET_CRADLE_MOUNT_CONFIG_RESP_V02 0x004F
+#define QMI_LOC_SET_CRADLE_MOUNT_CONFIG_IND_V02 0x004F
+#define QMI_LOC_GET_CRADLE_MOUNT_CONFIG_REQ_V02 0x0050
+#define QMI_LOC_GET_CRADLE_MOUNT_CONFIG_RESP_V02 0x0050
+#define QMI_LOC_GET_CRADLE_MOUNT_CONFIG_IND_V02 0x0050
+#define QMI_LOC_SET_EXTERNAL_POWER_CONFIG_REQ_V02 0x0051
+#define QMI_LOC_SET_EXTERNAL_POWER_CONFIG_RESP_V02 0x0051
+#define QMI_LOC_SET_EXTERNAL_POWER_CONFIG_IND_V02 0x0051
+#define QMI_LOC_GET_EXTERNAL_POWER_CONFIG_REQ_V02 0x0052
+#define QMI_LOC_GET_EXTERNAL_POWER_CONFIG_RESP_V02 0x0052
+#define QMI_LOC_GET_EXTERNAL_POWER_CONFIG_IND_V02 0x0052
+#define QMI_LOC_INFORM_LOCATION_SERVER_CONN_STATUS_REQ_V02 0x0053
+#define QMI_LOC_INFORM_LOCATION_SERVER_CONN_STATUS_RESP_V02 0x0053
+#define QMI_LOC_INFORM_LOCATION_SERVER_CONN_STATUS_IND_V02 0x0053
+#define QMI_LOC_SET_PROTOCOL_CONFIG_PARAMETERS_REQ_V02 0x0054
+#define QMI_LOC_SET_PROTOCOL_CONFIG_PARAMETERS_RESP_V02 0x0054
+#define QMI_LOC_SET_PROTOCOL_CONFIG_PARAMETERS_IND_V02 0x0054
+#define QMI_LOC_GET_PROTOCOL_CONFIG_PARAMETERS_REQ_V02 0x0055
+#define QMI_LOC_GET_PROTOCOL_CONFIG_PARAMETERS_RESP_V02 0x0055
+#define QMI_LOC_GET_PROTOCOL_CONFIG_PARAMETERS_IND_V02 0x0055
+#define QMI_LOC_SET_SENSOR_CONTROL_CONFIG_REQ_V02 0x0056
+#define QMI_LOC_SET_SENSOR_CONTROL_CONFIG_RESP_V02 0x0056
+#define QMI_LOC_SET_SENSOR_CONTROL_CONFIG_IND_V02 0x0056
+#define QMI_LOC_GET_SENSOR_CONTROL_CONFIG_REQ_V02 0x0057
+#define QMI_LOC_GET_SENSOR_CONTROL_CONFIG_RESP_V02 0x0057
+#define QMI_LOC_GET_SENSOR_CONTROL_CONFIG_IND_V02 0x0057
+#define QMI_LOC_SET_SENSOR_PROPERTIES_REQ_V02 0x0058
+#define QMI_LOC_SET_SENSOR_PROPERTIES_RESP_V02 0x0058
+#define QMI_LOC_SET_SENSOR_PROPERTIES_IND_V02 0x0058
+#define QMI_LOC_GET_SENSOR_PROPERTIES_REQ_V02 0x0059
+#define QMI_LOC_GET_SENSOR_PROPERTIES_RESP_V02 0x0059
+#define QMI_LOC_GET_SENSOR_PROPERTIES_IND_V02 0x0059
+#define QMI_LOC_SET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_REQ_V02 0x005A
+#define QMI_LOC_SET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_RESP_V02 0x005A
+#define QMI_LOC_SET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_IND_V02 0x005A
+#define QMI_LOC_GET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_REQ_V02 0x005B
+#define QMI_LOC_GET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_RESP_V02 0x005B
+#define QMI_LOC_GET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_IND_V02 0x005B
+#define QMI_LOC_INJECT_SUPL_CERTIFICATE_REQ_V02 0x005C
+#define QMI_LOC_INJECT_SUPL_CERTIFICATE_RESP_V02 0x005C
+#define QMI_LOC_INJECT_SUPL_CERTIFICATE_IND_V02 0x005C
+#define QMI_LOC_DELETE_SUPL_CERTIFICATE_REQ_V02 0x005D
+#define QMI_LOC_DELETE_SUPL_CERTIFICATE_RESP_V02 0x005D
+#define QMI_LOC_DELETE_SUPL_CERTIFICATE_IND_V02 0x005D
+#define QMI_LOC_SET_POSITION_ENGINE_CONFIG_PARAMETERS_REQ_V02 0x005E
+#define QMI_LOC_SET_POSITION_ENGINE_CONFIG_PARAMETERS_RESP_V02 0x005E
+#define QMI_LOC_SET_POSITION_ENGINE_CONFIG_PARAMETERS_IND_V02 0x005E
+#define QMI_LOC_GET_POSITION_ENGINE_CONFIG_PARAMETERS_REQ_V02 0x005F
+#define QMI_LOC_GET_POSITION_ENGINE_CONFIG_PARAMETERS_RESP_V02 0x005F
+#define QMI_LOC_GET_POSITION_ENGINE_CONFIG_PARAMETERS_IND_V02 0x005F
+#define QMI_LOC_EVENT_NI_GEOFENCE_NOTIFICATION_IND_V02 0x0060
+#define QMI_LOC_EVENT_GEOFENCE_GEN_ALERT_IND_V02 0x0061
+#define QMI_LOC_EVENT_GEOFENCE_BREACH_NOTIFICATION_IND_V02 0x0062
+#define QMI_LOC_ADD_CIRCULAR_GEOFENCE_REQ_V02 0x0063
+#define QMI_LOC_ADD_CIRCULAR_GEOFENCE_RESP_V02 0x0063
+#define QMI_LOC_ADD_CIRCULAR_GEOFENCE_IND_V02 0x0063
+#define QMI_LOC_DELETE_GEOFENCE_REQ_V02 0x0064
+#define QMI_LOC_DELETE_GEOFENCE_RESP_V02 0x0064
+#define QMI_LOC_DELETE_GEOFENCE_IND_V02 0x0064
+#define QMI_LOC_QUERY_GEOFENCE_REQ_V02 0x0065
+#define QMI_LOC_QUERY_GEOFENCE_RESP_V02 0x0065
+#define QMI_LOC_QUERY_GEOFENCE_IND_V02 0x0065
+#define QMI_LOC_EDIT_GEOFENCE_REQ_V02 0x0066
+#define QMI_LOC_EDIT_GEOFENCE_RESP_V02 0x0066
+#define QMI_LOC_EDIT_GEOFENCE_IND_V02 0x0066
+#define QMI_LOC_GET_BEST_AVAILABLE_POSITION_REQ_V02 0x0067
+#define QMI_LOC_GET_BEST_AVAILABLE_POSITION_RESP_V02 0x0067
+#define QMI_LOC_GET_BEST_AVAILABLE_POSITION_IND_V02 0x0067
+#define QMI_LOC_INJECT_MOTION_DATA_REQ_V02 0x0068
+#define QMI_LOC_INJECT_MOTION_DATA_RESP_V02 0x0068
+#define QMI_LOC_INJECT_MOTION_DATA_IND_V02 0x0068
+#define QMI_LOC_GET_NI_GEOFENCE_ID_LIST_REQ_V02 0x0069
+#define QMI_LOC_GET_NI_GEOFENCE_ID_LIST_RESP_V02 0x0069
+#define QMI_LOC_GET_NI_GEOFENCE_ID_LIST_IND_V02 0x0069
+#define QMI_LOC_INJECT_GSM_CELL_INFO_REQ_V02 0x006A
+#define QMI_LOC_INJECT_GSM_CELL_INFO_RESP_V02 0x006A
+#define QMI_LOC_INJECT_GSM_CELL_INFO_IND_V02 0x006A
+#define QMI_LOC_INJECT_NETWORK_INITIATED_MESSAGE_REQ_V02 0x006B
+#define QMI_LOC_INJECT_NETWORK_INITIATED_MESSAGE_RESP_V02 0x006B
+#define QMI_LOC_INJECT_NETWORK_INITIATED_MESSAGE_IND_V02 0x006B
+#define QMI_LOC_WWAN_OUT_OF_SERVICE_NOTIFICATION_REQ_V02 0x006C
+#define QMI_LOC_WWAN_OUT_OF_SERVICE_NOTIFICATION_RESP_V02 0x006C
+#define QMI_LOC_WWAN_OUT_OF_SERVICE_NOTIFICATION_IND_V02 0x006C
+#define QMI_LOC_EVENT_PEDOMETER_CONTROL_IND_V02 0x006D
+#define QMI_LOC_EVENT_MOTION_DATA_CONTROL_IND_V02 0x006E
+#define QMI_LOC_PEDOMETER_REPORT_REQ_V02 0x006F
+#define QMI_LOC_PEDOMETER_REPORT_RESP_V02 0x006F
+#define QMI_LOC_PEDOMETER_REPORT_IND_V02 0x006F
+#define QMI_LOC_INJECT_WCDMA_CELL_INFO_REQ_V02 0x0070
+#define QMI_LOC_INJECT_WCDMA_CELL_INFO_RESP_V02 0x0070
+#define QMI_LOC_INJECT_WCDMA_CELL_INFO_IND_V02 0x0070
+#define QMI_LOC_INJECT_TDSCDMA_CELL_INFO_REQ_V02 0x0071
+#define QMI_LOC_INJECT_TDSCDMA_CELL_INFO_RESP_V02 0x0071
+#define QMI_LOC_INJECT_TDSCDMA_CELL_INFO_IND_V02 0x0071
+#define QMI_LOC_INJECT_SUBSCRIBER_ID_REQ_V02 0x0072
+#define QMI_LOC_INJECT_SUBSCRIBER_ID_RESP_V02 0x0072
+#define QMI_LOC_INJECT_SUBSCRIBER_ID_IND_V02 0x0072
+#define QMI_LOC_SET_GEOFENCE_ENGINE_CONFIG_REQ_V02 0x0073
+#define QMI_LOC_SET_GEOFENCE_ENGINE_CONFIG_RESP_V02 0x0073
+#define QMI_LOC_SET_GEOFENCE_ENGINE_CONFIG_IND_V02 0x0073
+#define QMI_LOC_GET_GEOFENCE_ENGINE_CONFIG_REQ_V02 0x0074
+#define QMI_LOC_GET_GEOFENCE_ENGINE_CONFIG_RESP_V02 0x0074
+#define QMI_LOC_GET_GEOFENCE_ENGINE_CONFIG_IND_V02 0x0074
+#define QMI_LOC_GET_BATCH_SIZE_REQ_V02 0x0075
+#define QMI_LOC_GET_BATCH_SIZE_RESP_V02 0x0075
+#define QMI_LOC_GET_BATCH_SIZE_IND_V02 0x0075
+#define QMI_LOC_START_BATCHING_REQ_V02 0x0076
+#define QMI_LOC_START_BATCHING_RESP_V02 0x0076
+#define QMI_LOC_START_BATCHING_IND_V02 0x0076
+#define QMI_LOC_EVENT_BATCH_FULL_NOTIFICATION_IND_V02 0x0077
+#define QMI_LOC_EVENT_LIVE_BATCHED_POSITION_REPORT_IND_V02 0x0078
+#define QMI_LOC_READ_FROM_BATCH_REQ_V02 0x0079
+#define QMI_LOC_READ_FROM_BATCH_RESP_V02 0x0079
+#define QMI_LOC_READ_FROM_BATCH_IND_V02 0x0079
+#define QMI_LOC_STOP_BATCHING_REQ_V02 0x007A
+#define QMI_LOC_STOP_BATCHING_RESP_V02 0x007A
+#define QMI_LOC_STOP_BATCHING_IND_V02 0x007A
+#define QMI_LOC_RELEASE_BATCH_REQ_V02 0x007B
+#define QMI_LOC_RELEASE_BATCH_RESP_V02 0x007B
+#define QMI_LOC_RELEASE_BATCH_IND_V02 0x007B
+#define QMI_LOC_EVENT_INJECT_WIFI_AP_DATA_REQ_IND_V02 0x007C
+#define QMI_LOC_INJECT_WIFI_AP_DATA_REQ_V02 0x007D
+#define QMI_LOC_INJECT_WIFI_AP_DATA_RESP_V02 0x007D
+#define QMI_LOC_INJECT_WIFI_AP_DATA_IND_V02 0x007D
+#define QMI_LOC_NOTIFY_WIFI_ATTACHMENT_STATUS_REQ_V02 0x007E
+#define QMI_LOC_NOTIFY_WIFI_ATTACHMENT_STATUS_RESP_V02 0x007E
+#define QMI_LOC_NOTIFY_WIFI_ATTACHMENT_STATUS_IND_V02 0x007E
+#define QMI_LOC_NOTIFY_WIFI_ENABLED_STATUS_REQ_V02 0x007F
+#define QMI_LOC_NOTIFY_WIFI_ENABLED_STATUS_RESP_V02 0x007F
+#define QMI_LOC_NOTIFY_WIFI_ENABLED_STATUS_IND_V02 0x007F
+#define QMI_LOC_EVENT_GEOFENCE_BATCHED_BREACH_NOTIFICATION_IND_V02 0x0080
+#define QMI_LOC_EVENT_VEHICLE_DATA_READY_STATUS_IND_V02 0x0081
+#define QMI_LOC_INJECT_VEHICLE_SENSOR_DATA_REQ_V02 0x0082
+#define QMI_LOC_INJECT_VEHICLE_SENSOR_DATA_RESP_V02 0x0082
+#define QMI_LOC_INJECT_VEHICLE_SENSOR_DATA_IND_V02 0x0082
+#define QMI_LOC_GET_AVAILABLE_WWAN_POSITION_REQ_V02 0x0083
+#define QMI_LOC_GET_AVAILABLE_WWAN_POSITION_RESP_V02 0x0083
+#define QMI_LOC_GET_AVAILABLE_WWAN_POSITION_IND_V02 0x0083
+#define QMI_LOC_SET_PREMIUM_SERVICES_CONFIG_REQ_V02 0x0084
+#define QMI_LOC_SET_PREMIUM_SERVICES_CONFIG_RESP_V02 0x0084
+#define QMI_LOC_SET_PREMIUM_SERVICES_CONFIG_IND_V02 0x0084
+#define QMI_LOC_SET_XTRA_VERSION_CHECK_REQ_V02 0x0085
+#define QMI_LOC_SET_XTRA_VERSION_CHECK_RESP_V02 0x0085
+#define QMI_LOC_SET_XTRA_VERSION_CHECK_IND_V02 0x0085
+#define QMI_LOC_EVENT_GNSS_MEASUREMENT_REPORT_IND_V02 0x0086
+#define QMI_LOC_EVENT_SV_POLYNOMIAL_REPORT_IND_V02 0x0087
+#define QMI_LOC_SET_GNSS_CONSTELL_REPORT_CONFIG_V02 0x0088
+#define QMI_LOC_SET_GNSS_CONSTELL_REPORT_CONFIG_RESP_V02 0x0088
+#define QMI_LOC_SET_GNSS_CONSTELL_REPORT_CONFIG_IND_V02 0x0088
+#define QMI_LOC_ADD_GEOFENCE_CONTEXT_REQ_V02 0x0089
+#define QMI_LOC_ADD_GEOFENCE_CONTEXT_RESP_V02 0x0089
+#define QMI_LOC_ADD_GEOFENCE_CONTEXT_IND_V02 0x0089
+#define QMI_LOC_SET_GEOFENCE_ENGINE_CONTEXT_REQ_V02 0x008A
+#define QMI_LOC_SET_GEOFENCE_ENGINE_CONTEXT_RESP_V02 0x008A
+#define QMI_LOC_SET_GEOFENCE_ENGINE_CONTEXT_IND_V02 0x008A
+#define QMI_LOC_DELETE_GEOFENCE_CONTEXT_REQ_V02 0x008B
+#define QMI_LOC_DELETE_GEOFENCE_CONTEXT_RESP_V02 0x008B
+#define QMI_LOC_DELETE_GEOFENCE_CONTEXT_IND_V02 0x008B
+#define QMI_LOC_EVENT_GEOFENCE_PROXIMITY_NOTIFICATION_IND_V02 0x008C
+#define QMI_LOC_INJECT_GTP_CLIENT_DOWNLOADED_DATA_REQ_V02 0x008D
+#define QMI_LOC_INJECT_GTP_CLIENT_DOWNLOADED_DATA_RESP_V02 0x008D
+#define QMI_LOC_INJECT_GTP_CLIENT_DOWNLOADED_DATA_IND_V02 0x008D
+#define QMI_LOC_GDT_UPLOAD_BEGIN_STATUS_REQ_V02 0x008E
+#define QMI_LOC_GDT_UPLOAD_BEGIN_STATUS_RESP_V02 0x008E
+#define QMI_LOC_GDT_UPLOAD_BEGIN_STATUS_IND_V02 0x008E
+#define QMI_LOC_GDT_UPLOAD_END_REQ_V02 0x008F
+#define QMI_LOC_GDT_UPLOAD_END_RESP_V02 0x008F
+#define QMI_LOC_GDT_UPLOAD_END_IND_V02 0x008F
+#define QMI_LOC_EVENT_GDT_UPLOAD_BEGIN_STATUS_REQ_IND_V02 0x0090
+#define QMI_LOC_EVENT_GDT_UPLOAD_END_REQ_IND_V02 0x0091
+#define QMI_LOC_START_DBT_REQ_V02 0x0092
+#define QMI_LOC_START_DBT_RESP_V02 0x0092
+#define QMI_LOC_START_DBT_IND_V02 0x0092
+#define QMI_LOC_EVENT_DBT_POSITION_REPORT_IND_V02 0x0093
+#define QMI_LOC_EVENT_DBT_SESSION_STATUS_IND_V02 0x0094
+#define QMI_LOC_STOP_DBT_REQ_V02 0x0095
+#define QMI_LOC_STOP_DBT_RESP_V02 0x0095
+#define QMI_LOC_STOP_DBT_IND_V02 0x0095
+#define QMI_LOC_SECURE_GET_AVAILABLE_POSITION_REQ_V02 0x0096
+#define QMI_LOC_SECURE_GET_AVAILABLE_POSITION_RESP_V02 0x0096
+#define QMI_LOC_SECURE_GET_AVAILABLE_POSITION_IND_V02 0x0096
+#define QMI_LOC_EVENT_GEOFENCE_BATCHED_DWELL_NOTIFICATION_IND_V02 0x0097
+#define QMI_LOC_EVENT_GET_TIME_ZONE_INFO_IND_V02 0x0098
+#define QMI_LOC_INJECT_TIME_ZONE_INFO_REQ_V02 0x0099
+#define QMI_LOC_INJECT_TIME_ZONE_INFO_RESP_V02 0x0099
+#define QMI_LOC_INJECT_TIME_ZONE_INFO_IND_V02 0x0099
+#define QMI_LOC_INJECT_APCACHE_DATA_REQ_V02 0x009A
+#define QMI_LOC_INJECT_APCACHE_DATA_RESP_V02 0x009A
+#define QMI_LOC_INJECT_APCACHE_DATA_IND_V02 0x009A
+#define QMI_LOC_INJECT_APDONOTCACHE_DATA_REQ_V02 0x009B
+#define QMI_LOC_INJECT_APDONOTCACHE_DATA_RESP_V02 0x009B
+#define QMI_LOC_INJECT_APDONOTCACHE_DATA_IND_V02 0x009B
+#define QMI_LOC_EVENT_BATCHING_STATUS_IND_V02 0x009C
+#define QMI_LOC_QUERY_AON_CONFIG_REQ_V02 0x009D
+#define QMI_LOC_QUERY_AON_CONFIG_RESP_V02 0x009D
+#define QMI_LOC_QUERY_AON_CONFIG_IND_V02 0x009D
+#define QMI_LOC_GTP_AP_STATUS_REQ_V02 0x009E
+#define QMI_LOC_GTP_AP_STATUS_RESP_V02 0x009E
+#define QMI_LOC_GTP_AP_STATUS_IND_V02 0x009E
+#define QMI_LOC_GDT_DOWNLOAD_BEGIN_STATUS_REQ_V02 0x009F
+#define QMI_LOC_GDT_DOWNLOAD_BEGIN_STATUS_RESP_V02 0x009F
+#define QMI_LOC_GDT_DOWNLOAD_BEGIN_STATUS_IND_V02 0x009F
+#define QMI_LOC_GDT_DOWNLOAD_READY_STATUS_REQ_V02 0x00A0
+#define QMI_LOC_GDT_DOWNLOAD_READY_STATUS_RESP_V02 0x00A0
+#define QMI_LOC_GDT_DOWNLOAD_READY_STATUS_IND_V02 0x00A0
+#define QMI_LOC_GDT_RECEIVE_DONE_STATUS_REQ_V02 0x00A1
+#define QMI_LOC_GDT_RECEIVE_DONE_STATUS_RESP_V02 0x00A1
+#define QMI_LOC_GDT_RECEIVE_DONE_STATUS_IND_V02 0x00A1
+#define QMI_LOC_GDT_DOWNLOAD_END_STATUS_REQ_V02 0x00A2
+#define QMI_LOC_GDT_DOWNLOAD_END_STATUS_RESP_V02 0x00A2
+#define QMI_LOC_GDT_DOWNLOAD_END_STATUS_IND_V02 0x00A2
+#define QMI_LOC_EVENT_GDT_DOWNLOAD_BEGIN_REQ_IND_V02 0x00A3
+#define QMI_LOC_EVENT_GDT_RECEIVE_DONE_IND_V02 0x00A4
+#define QMI_LOC_EVENT_GDT_DOWNLOAD_END_REQ_IND_V02 0x00A5
+#define QMI_LOC_DELETE_GNSS_SERVICE_DATA_REQ_V02 0x00A6
+#define QMI_LOC_DELETE_GNSS_SERVICE_DATA_RESP_V02 0x00A6
+#define QMI_LOC_DELETE_GNSS_SERVICE_DATA_IND_V02 0x00A6
+#define QMI_LOC_INJECT_XTRA_DATA_REQ_V02 0x00A7
+#define QMI_LOC_INJECT_XTRA_DATA_RESP_V02 0x00A7
+#define QMI_LOC_INJECT_XTRA_DATA_IND_V02 0x00A7
+#define QMI_LOC_INJECT_XTRA_PCID_REQ_V02 0x00A8
+#define QMI_LOC_INJECT_XTRA_PCID_RESP_V02 0x00A8
+#define QMI_LOC_INJECT_XTRA_PCID_IND_V02 0x00A8
+#define QMI_LOC_GET_SUPPORTED_FEATURE_REQ_V02 0x00A9
+#define QMI_LOC_GET_SUPPORTED_FEATURE_RESP_V02 0x00A9
+#define QMI_LOC_GET_SUPPORTED_FEATURE_IND_V02 0x00A9
+/**
+    @}
+  */
+
+/* Service Object Accessor */
+/** @addtogroup wms_qmi_accessor
+    @{
+  */
+/** This function is used internally by the autogenerated code.  Clients should use the
+   macro loc_get_service_object_v02( ) that takes in no arguments. */
+qmi_idl_service_object_type loc_get_service_object_internal_v02
+ ( int32_t idl_maj_version, int32_t idl_min_version, int32_t library_version );
+
+/** This macro should be used to get the service object */
+#define loc_get_service_object_v02( ) \
+          loc_get_service_object_internal_v02( \
+            LOC_V02_IDL_MAJOR_VERS, LOC_V02_IDL_MINOR_VERS, \
+            LOC_V02_IDL_TOOL_VERS )
+/**
+    @}
+  */
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+