diff --git a/src/datasources/asset/AssetConfigEditor.tsx b/src/datasources/asset/AssetConfigEditor.tsx
index 03c8105e..44cd566d 100644
--- a/src/datasources/asset/AssetConfigEditor.tsx
+++ b/src/datasources/asset/AssetConfigEditor.tsx
@@ -56,6 +56,14 @@ export const AssetConfigEditor: React.FC<Props> = ({ options, onOptionsChange })
           </InlineField>
           <Tag name='Beta' colorIndex={5} />
         </InlineSegmentGroup>
+        <InlineSegmentGroup>
+          <InlineField label="Advanced Filter" labelWidth={25}>
+            <InlineSwitch
+              value={options.jsonData?.featureToggles?.advancedFilter ?? AssetFeatureTogglesDefaults.advancedFilter}
+              onChange={handleFeatureChange('advancedFilter')} />
+          </InlineField>
+          <Tag name='Beta' colorIndex={5} />
+        </InlineSegmentGroup>
       </>
     </>
   );
diff --git a/src/datasources/asset/AssetDataSource.test.ts b/src/datasources/asset/AssetDataSource.test.ts
index 51c0bea2..523f27f9 100644
--- a/src/datasources/asset/AssetDataSource.test.ts
+++ b/src/datasources/asset/AssetDataSource.test.ts
@@ -12,6 +12,7 @@ import { AssetQueryType } from "./types/types";
 import { AssetPresenceWithSystemConnectionModel, AssetsResponse } from "datasources/asset-common/types";
 import { ListAssetsQuery } from "./types/ListAssets.types";
 import { AssetVariableQuery } from "./types/AssetVariableQuery.types";
+import { QueryBuilderType } from "./constants/constants";
 
 let ds: AssetDataSource, backendSrv: MockProxy<BackendSrv>
 let assetOptions = {
@@ -306,10 +307,10 @@ const assetsWithoutNameResponseMock: AssetsResponse =
   "totalCount": 2
 }
 
-
 const assetMetadataQueryMock: ListAssetsQuery = {
   type: AssetQueryType.ListAssets,
   filter: 'Location.MinionId == "123"',
+  queryBuilderType: QueryBuilderType.Simple,
   refId: ''
 }
 
@@ -362,6 +363,7 @@ describe('queries', () => {
       const query: AssetVariableQuery = {
         filter: '',
         type: AssetQueryType.None,
+        queryBuilderType: QueryBuilderType.Simple,
         refId: ""
       }
 
@@ -382,6 +384,7 @@ describe('queries', () => {
       const query: AssetVariableQuery = {
         filter: '',
         type: AssetQueryType.None,
+        queryBuilderType: QueryBuilderType.Simple,
         refId: ""
       }
 
diff --git a/src/datasources/asset/AssetDataSource.ts b/src/datasources/asset/AssetDataSource.ts
index 055d6c10..3fc1b059 100644
--- a/src/datasources/asset/AssetDataSource.ts
+++ b/src/datasources/asset/AssetDataSource.ts
@@ -20,7 +20,7 @@ import { ListAssetsQuery } from './types/ListAssets.types';
 import { ListAssetsDataSource } from './data-sources/list-assets/ListAssetsDataSource';
 import { AssetSummaryDataSource } from './data-sources/asset-summary/AssetSummaryDataSource';
 import { AssetModel } from 'datasources/asset-common/types';
-import { QUERY_LIMIT } from './constants/constants';
+import { QUERY_LIMIT, QueryBuilderType } from './constants/constants';
 import { transformComputedFieldsQuery } from 'core/query-builder.utils';
 import { AssetVariableQuery } from './types/AssetVariableQuery.types';
 
@@ -44,6 +44,7 @@ export class AssetDataSource extends DataSourceBase<AssetQuery, AssetDataSourceO
 
   defaultQuery = {
     type: AssetQueryType.None,
+    queryBuilderType: QueryBuilderType.Simple,
   };
 
   async runQuery(query: AssetQuery, options: DataQueryRequest): Promise<DataFrameDTO> {
diff --git a/src/datasources/asset/components/AssetQueryEditor.tsx b/src/datasources/asset/components/AssetQueryEditor.tsx
index 3f9b48b2..8af04b54 100644
--- a/src/datasources/asset/components/AssetQueryEditor.tsx
+++ b/src/datasources/asset/components/AssetQueryEditor.tsx
@@ -21,6 +21,7 @@ export function AssetQueryEditor({ query, onChange, onRunQuery, datasource }: Pr
     assetList: datasource.instanceSettings.jsonData?.featureToggles?.assetList ?? AssetFeatureTogglesDefaults.assetList,
     calibrationForecast: datasource.instanceSettings.jsonData?.featureToggles?.calibrationForecast ?? AssetFeatureTogglesDefaults.calibrationForecast,
     assetSummary: datasource.instanceSettings.jsonData?.featureToggles?.assetSummary ?? AssetFeatureTogglesDefaults.assetSummary,
+    advancedFilter: datasource.instanceSettings.jsonData?.featureToggles?.advancedFilter ?? AssetFeatureTogglesDefaults.advancedFilter,
   });
 
   const handleQueryChange = useCallback((value: AssetQuery, runQuery = false): void => {
@@ -78,6 +79,7 @@ export function AssetQueryEditor({ query, onChange, onRunQuery, datasource }: Pr
           query={query as ListAssetsQuery}
           handleQueryChange={handleQueryChange}
           datasource={datasource.getListAssetsSource()}
+          complexFilterEnabled={assetFeatures.current.advancedFilter}
         />
       )}
       {((assetFeatures.current.calibrationForecast && queryType === AssetQueryType.CalibrationForecast) || (query.type === AssetQueryType.CalibrationForecast)) && (
diff --git a/src/datasources/asset/components/editors/asset-summary/AssetSummaryEditor.test.tsx b/src/datasources/asset/components/editors/asset-summary/AssetSummaryEditor.test.tsx
index 5471528d..d5e575b1 100644
--- a/src/datasources/asset/components/editors/asset-summary/AssetSummaryEditor.test.tsx
+++ b/src/datasources/asset/components/editors/asset-summary/AssetSummaryEditor.test.tsx
@@ -6,6 +6,7 @@ import { AssetSummaryResponse } from 'datasources/asset/types/AssetSummaryQuery.
 import { AssetDataSourceOptions, AssetQuery, AssetQueryType } from 'datasources/asset/types/types';
 import { AssetSummaryDataSource } from '../../../data-sources/asset-summary/AssetSummaryDataSource';
 import { assetSummaryFields } from '../../../constants/AssetSummaryQuery.constants';
+import { QueryBuilderType } from 'datasources/asset/constants/constants';
 
 describe('AssetSummaryDataSource', () => {
   let dataSource: AssetSummaryDataSource;
@@ -25,7 +26,7 @@ describe('AssetSummaryDataSource', () => {
   });
 
   it('should process metadata query correctly', async () => {
-    const query: AssetQuery = { refId: 'A', type: AssetQueryType.AssetSummary, };
+    const query: AssetQuery = { refId: 'A', type: AssetQueryType.AssetSummary, queryBuilderType: QueryBuilderType.Simple, };
 
     jest.spyOn(dataSource, 'getAssetSummary').mockResolvedValue(assetSummary);
     const result = await dataSource.processSummaryQuery(query);
diff --git a/src/datasources/asset/components/editors/calibration-forecast/CalibrationForecastEditor.test.tsx b/src/datasources/asset/components/editors/calibration-forecast/CalibrationForecastEditor.test.tsx
index 0f3ef2b4..7b2f3b5d 100644
--- a/src/datasources/asset/components/editors/calibration-forecast/CalibrationForecastEditor.test.tsx
+++ b/src/datasources/asset/components/editors/calibration-forecast/CalibrationForecastEditor.test.tsx
@@ -10,6 +10,7 @@ import { CalibrationForecastDataSource } from '../../../data-sources/calibration
 import { AssetQueryEditor } from '../../AssetQueryEditor';
 import { AssetDataSource } from '../../../AssetDataSource';
 import { AssetQueryType } from '../../../types/types';
+import { QueryBuilderType } from 'datasources/asset/constants/constants';
 
 class FakeAssetCalibrationDataSource extends CalibrationForecastDataSource {}
 
@@ -72,6 +73,7 @@ describe('CalibrationForecastEditor', () => {
       refId: '',
       groupBy: [],
       type: AssetQueryType.CalibrationForecast,
+      queryBuilderType: QueryBuilderType.Simple,
     } as CalibrationForecastQuery);
 
     // User selects group by location
diff --git a/src/datasources/asset/components/editors/calibration-forecast/query-builder/CalibrationForecastQueryBuilder.tsx b/src/datasources/asset/components/editors/calibration-forecast/query-builder/CalibrationForecastQueryBuilder.tsx
index 2564d440..a8d62ea2 100644
--- a/src/datasources/asset/components/editors/calibration-forecast/query-builder/CalibrationForecastQueryBuilder.tsx
+++ b/src/datasources/asset/components/editors/calibration-forecast/query-builder/CalibrationForecastQueryBuilder.tsx
@@ -119,6 +119,7 @@ export const CalibrationForecastQueryBuilder: React.FC<CalibrationForecastQueryB
       messages={queryBuilderMessages}
       onChange={onChange}
       value={sanitizedFilter}
+      style={{width: '520px'}}
       />
   );
 };
diff --git a/src/datasources/asset/components/editors/list-assets/ListAssetsEditor.test.tsx b/src/datasources/asset/components/editors/list-assets/ListAssetsEditor.test.tsx
index eea1d489..59b5916b 100644
--- a/src/datasources/asset/components/editors/list-assets/ListAssetsEditor.test.tsx
+++ b/src/datasources/asset/components/editors/list-assets/ListAssetsEditor.test.tsx
@@ -6,6 +6,7 @@ import { setupRenderer } from '../../../../../test/fixtures';
 import { ListAssetsQuery } from '../../../types/ListAssets.types';
 import { AssetFeatureTogglesDefaults } from 'datasources/asset/types/types';
 import { ListAssetsDataSource } from '../../../data-sources/list-assets/ListAssetsDataSource';
+import { QueryBuilderType } from 'datasources/asset/constants/constants';
 
 const fakeSystems: SystemMetadata[] = [
   {
@@ -52,7 +53,7 @@ it('does not render when feature is not enabled', async () => {
 
 it('renders the query builder', async () => {
   assetDatasourceOptions.featureToggles.assetList = true;
-  render({} as ListAssetsQuery);
+  render({queryBuilderType: QueryBuilderType.Simple} as ListAssetsQuery);
 
   await waitFor(() => expect(screen.getAllByText('Property').length).toBe(1));
   await waitFor(() => expect(screen.getAllByText('Operator').length).toBe(1));
diff --git a/src/datasources/asset/components/editors/list-assets/ListAssetsEditor.tsx b/src/datasources/asset/components/editors/list-assets/ListAssetsEditor.tsx
index 909f82b0..1991ed07 100644
--- a/src/datasources/asset/components/editors/list-assets/ListAssetsEditor.tsx
+++ b/src/datasources/asset/components/editors/list-assets/ListAssetsEditor.tsx
@@ -14,9 +14,10 @@ type Props = {
   query: ListAssetsQuery;
   handleQueryChange: (value: AssetQuery, runQuery: boolean) => void;
   datasource: ListAssetsDataSource;
+  complexFilterEnabled: boolean;
 };
 
-export function ListAssetsEditor({ query, handleQueryChange, datasource }: Props) {
+export function ListAssetsEditor({ query, handleQueryChange, datasource, complexFilterEnabled }: Props) {
   const [workspaces, setWorkspaces] = useState<Workspace[]>([]);
   const [systems, setSystems] = useState<SystemMetadata[]>([]);
   const [areDependenciesLoaded, setAreDependenciesLoaded] = useState<boolean>(false);
@@ -50,6 +51,9 @@ export function ListAssetsEditor({ query, handleQueryChange, datasource }: Props
           globalVariableOptions={datasource.globalVariableOptions()}
           areDependenciesLoaded={areDependenciesLoaded}
           onChange={(event: any) => onParameterChange(event)}
+          query={query}
+          handleQueryChange={handleQueryChange}
+          complexFilterEnabled={complexFilterEnabled}
         ></AssetQueryBuilder>
 
       </InlineField>
diff --git a/src/datasources/asset/components/editors/list-assets/query-builder/AssetQueryBuilder.test.tsx b/src/datasources/asset/components/editors/list-assets/query-builder/AssetQueryBuilder.test.tsx
index 12cec816..b8ec16f9 100644
--- a/src/datasources/asset/components/editors/list-assets/query-builder/AssetQueryBuilder.test.tsx
+++ b/src/datasources/asset/components/editors/list-assets/query-builder/AssetQueryBuilder.test.tsx
@@ -3,6 +3,7 @@ import { AssetQueryBuilder } from './AssetQueryBuilder';
 import { render } from '@testing-library/react';
 import { QueryBuilderOption, Workspace } from 'core/types';
 import { SystemMetadata } from 'datasources/system/types';
+import { QueryBuilderType } from 'datasources/asset/constants/constants';
 
 describe('AssetQueryBuilder', () => {
   describe('useEffects', () => {
@@ -10,7 +11,7 @@ describe('AssetQueryBuilder', () => {
 
     const containerClass = 'smart-filter-group-condition-container';
 
-    function renderElement(workspaces: Workspace[], systems: SystemMetadata[], filter?: string, globalVariableOptions: QueryBuilderOption[] = []) {
+    function renderElement(workspaces: Workspace[], systems: SystemMetadata[], filter?: string, globalVariableOptions: QueryBuilderOption[] = [], complexFilterEnabled = true, queryBuilderType = QueryBuilderType.Simple) {
       reactNode = React.createElement(AssetQueryBuilder, {
         workspaces,
         systems,
@@ -18,6 +19,9 @@ describe('AssetQueryBuilder', () => {
         globalVariableOptions,
         onChange: jest.fn(),
         areDependenciesLoaded: true,
+        query: {queryBuilderType: queryBuilderType} as any,
+        handleQueryChange: jest.fn(),
+        complexFilterEnabled: complexFilterEnabled,
       });
       const renderResult = render(reactNode);
       return {
@@ -30,6 +34,14 @@ describe('AssetQueryBuilder', () => {
       const { renderResult, conditionsContainer } = renderElement([], [], '');
       expect(conditionsContainer.length).toBe(1);
       expect(renderResult.findByLabelText('Empty condition row')).toBeTruthy();
+      expect(renderResult.queryByText('Advanced')).not.toBeNull();
+    });
+
+    it('should not render complex option if complexFilterEnabled is disabled', () => {
+      const { renderResult, conditionsContainer } = renderElement([], [], '', [], false);
+      expect(conditionsContainer.length).toBe(1);
+      expect(renderResult.findByLabelText('Empty condition row')).toBeTruthy();
+      expect(renderResult.queryByText('Advanced')).toBeNull();
     });
 
     it('should select workspace in query builder', () => {
@@ -82,5 +94,14 @@ describe('AssetQueryBuilder', () => {
       expect(conditionsContainer?.length).toBe(1);
       expect(conditionsContainer.item(0)?.innerHTML).not.toContain('alert(\'Workspace\')');
     })
+
+    it('should render the filter when advanced option is selected', () => {
+      const workspace = { id: '1', name: 'Selected workspace' } as Workspace;
+      const system = { id: '1', alias: 'Selected system' } as SystemMetadata;
+
+      const { renderResult } = renderElement([workspace], [system], 'Location = "1"', [], true, QueryBuilderType.Advanced);
+
+      expect(renderResult.queryByText('Location = "1"')).not.toBeNull();
+    })
   });
 });
diff --git a/src/datasources/asset/components/editors/list-assets/query-builder/AssetQueryBuilder.tsx b/src/datasources/asset/components/editors/list-assets/query-builder/AssetQueryBuilder.tsx
index 00cc811a..030bda45 100644
--- a/src/datasources/asset/components/editors/list-assets/query-builder/AssetQueryBuilder.tsx
+++ b/src/datasources/asset/components/editors/list-assets/query-builder/AssetQueryBuilder.tsx
@@ -1,6 +1,6 @@
-import React, { useEffect, useMemo, useState } from 'react';
+import React, { ChangeEvent, useCallback, useEffect, useMemo, useState } from 'react';
 import { QueryBuilder, QueryBuilderCustomOperation, QueryBuilderProps } from 'smart-webcomponents-react/querybuilder';
-import { useTheme2 } from '@grafana/ui';
+import { RadioButtonGroup, TextArea, useTheme2 } from '@grafana/ui';
 
 import 'smart-webcomponents-react/source/styles/smart.dark-orange.css';
 import 'smart-webcomponents-react/source/styles/smart.orange.css';
@@ -14,7 +14,9 @@ import { expressionBuilderCallback, expressionReaderCallback } from 'core/query-
 import { SystemMetadata } from 'datasources/system/types';
 import { QBField } from '../../../../types/CalibrationForecastQuery.types';
 import { ListAssetsFields, ListAssetsStaticFields } from '../../../../constants/ListAssets.constants';
-import { filterXSSField, filterXSSLINQExpression } from 'core/utils';
+import { enumToOptions, filterXSSField, filterXSSLINQExpression } from 'core/utils';
+import { QueryBuilderType } from 'datasources/asset/constants/constants';
+import { ListAssetsQuery } from 'datasources/asset/types/ListAssets.types';
 
 type AssetCalibrationQueryBuilderProps = QueryBuilderProps &
   React.HTMLAttributes<Element> & {
@@ -23,6 +25,9 @@ type AssetCalibrationQueryBuilderProps = QueryBuilderProps &
     systems: SystemMetadata[];
     globalVariableOptions: QueryBuilderOption[];
     areDependenciesLoaded: boolean;
+    query: ListAssetsQuery;
+    handleQueryChange: ( value: ListAssetsQuery, runQuery: boolean ) => void;
+    complexFilterEnabled: boolean;
   };
 
 export const AssetQueryBuilder: React.FC<AssetCalibrationQueryBuilderProps> = ({
@@ -32,6 +37,9 @@ export const AssetQueryBuilder: React.FC<AssetCalibrationQueryBuilderProps> = ({
   systems,
   globalVariableOptions,
   areDependenciesLoaded,
+  query,
+  handleQueryChange,
+  complexFilterEnabled
 }) => {
   const theme = useTheme2();
   document.body.setAttribute('theme', theme.isDark ? 'dark-orange' : 'orange');
@@ -43,6 +51,16 @@ export const AssetQueryBuilder: React.FC<AssetCalibrationQueryBuilderProps> = ({
     return filterXSSLINQExpression(filter);
   }, [filter])
 
+  const onFilterChange = useCallback((event: ChangeEvent<HTMLTextAreaElement>) =>
+  {
+    handleQueryChange({...query, filter: event.target.value}, false);
+  }, [query, handleQueryChange])
+
+  const handleQueryBuilderTypeChange = useCallback((newQueryBuilderType: QueryBuilderType) =>
+  {
+    handleQueryChange({...query, queryBuilderType: newQueryBuilderType}, false);
+  }, [query, handleQueryChange])
+
   const workspaceField = useMemo(() => {
     const workspaceField = ListAssetsFields.WORKSPACE;
 
@@ -154,12 +172,29 @@ export const AssetQueryBuilder: React.FC<AssetCalibrationQueryBuilderProps> = ({
   }, [workspaceField, locationField, calibrationDueDateField, areDependenciesLoaded, globalVariableOptions]);
 
   return (
-    <QueryBuilder
-      customOperations={operations}
-      fields={fields}
-      messages={queryBuilderMessages}
-      onChange={onChange}
-      value={sanitizedFilter}
-    />
+    <>
+      { complexFilterEnabled &&
+        <div style={{alignSelf: 'flex-end', textAlign: 'right', marginBottom: '4px'}}>
+          <RadioButtonGroup
+            options={enumToOptions(QueryBuilderType)}
+            onChange={handleQueryBuilderTypeChange}
+            value={query.queryBuilderType}
+            />
+        </div>
+      }
+      { (!complexFilterEnabled || query.queryBuilderType === QueryBuilderType.Simple) &&
+        <QueryBuilder
+          customOperations={operations}
+          fields={fields}
+          messages={queryBuilderMessages}
+          onChange={onChange}
+          value={sanitizedFilter}
+          style={{width: '520px'}}
+          />
+      }
+      { complexFilterEnabled && query.queryBuilderType === QueryBuilderType.Advanced &&
+        <TextArea style={{width: "520px"}} value={sanitizedFilter} onChange={onFilterChange} />
+      }
+    </>
   );
 };
diff --git a/src/datasources/asset/components/variable-editor/AssetVariableQueryEditor.test.tsx b/src/datasources/asset/components/variable-editor/AssetVariableQueryEditor.test.tsx
index 9e7df5af..86b683a3 100644
--- a/src/datasources/asset/components/variable-editor/AssetVariableQueryEditor.test.tsx
+++ b/src/datasources/asset/components/variable-editor/AssetVariableQueryEditor.test.tsx
@@ -6,6 +6,7 @@ import { Workspace } from 'core/types';
 import { setupRenderer } from 'test/fixtures';
 import { ListAssetsDataSource } from '../../data-sources/list-assets/ListAssetsDataSource';
 import { AssetDataSource } from 'datasources/asset/AssetDataSource';
+import { QueryBuilderType } from 'datasources/asset/constants/constants';
 
 const fakeSystems: SystemMetadata[] = [
     {
@@ -53,7 +54,7 @@ class FakeAssetDataSource extends AssetDataSource {
 const render = setupRenderer(AssetVariableQueryEditor, FakeAssetDataSource, () => {});
 
 it('renders the variable query builder', async () => {
-    render({  refId: '', type: AssetQueryType.ListAssets, filter: "" } as AssetQuery);
+    render({  refId: '', type: AssetQueryType.ListAssets, filter: "", queryBuilderType: QueryBuilderType.Simple, } as AssetQuery);
 
     await waitFor(() => expect(screen.getAllByText('Property').length).toBe(1));
     await waitFor(() => expect(screen.getAllByText('Operator').length).toBe(1));
diff --git a/src/datasources/asset/components/variable-editor/AssetVariableQueryEditor.tsx b/src/datasources/asset/components/variable-editor/AssetVariableQueryEditor.tsx
index c46e4979..38913812 100644
--- a/src/datasources/asset/components/variable-editor/AssetVariableQueryEditor.tsx
+++ b/src/datasources/asset/components/variable-editor/AssetVariableQueryEditor.tsx
@@ -1,6 +1,6 @@
-import React, { useEffect, useRef, useState } from 'react';
+import React, { useCallback, useEffect, useRef, useState } from 'react';
 import { QueryEditorProps } from "@grafana/data";
-import { AssetDataSourceOptions, AssetQuery } from '../../../asset/types/types';
+import { AssetDataSourceOptions, AssetFeatureToggles, AssetFeatureTogglesDefaults, AssetQuery } from '../../../asset/types/types';
 import { AssetDataSource } from '../../AssetDataSource'
 import { FloatingError } from '../../../../core/errors';
 import { AssetQueryBuilder } from '../editors/list-assets/query-builder/AssetQueryBuilder';
@@ -10,7 +10,14 @@ import { AssetVariableQuery } from '../../../asset/types/AssetVariableQuery.type
 
 type Props = QueryEditorProps<AssetDataSource, AssetQuery, AssetDataSourceOptions>;
 
-export function AssetVariableQueryEditor({ datasource, query, onChange }: Props) {
+export function AssetVariableQueryEditor ( { datasource, query, onRunQuery, onChange }: Props )
+{
+  const assetFeatures = useRef<AssetFeatureToggles>({
+    assetList: datasource.instanceSettings.jsonData?.featureToggles?.assetList ?? AssetFeatureTogglesDefaults.assetList,
+    calibrationForecast: datasource.instanceSettings.jsonData?.featureToggles?.calibrationForecast ?? AssetFeatureTogglesDefaults.calibrationForecast,
+    assetSummary: datasource.instanceSettings.jsonData?.featureToggles?.assetSummary ?? AssetFeatureTogglesDefaults.assetSummary,
+    advancedFilter: datasource.instanceSettings.jsonData?.featureToggles?.advancedFilter ?? AssetFeatureTogglesDefaults.advancedFilter,
+  });
   const [workspaces, setWorkspaces] = useState<Workspace[]>([]);
   const [systems, setSystems] = useState<SystemMetadata[]>([]);
   const [areDependenciesLoaded, setAreDependenciesLoaded] = useState<boolean>(false);
@@ -31,8 +38,15 @@ export function AssetVariableQueryEditor({ datasource, query, onChange }: Props)
     }
   }
 
+  const handleQueryChange = useCallback((value: AssetQuery, runQuery = false): void => {
+    onChange(value);
+    if (runQuery) {
+      onRunQuery();
+    }
+  }, [onChange, onRunQuery]);
+
   return (
-    <div style={{ width: "525px" }}>
+    <div style={{ width: "520px" }}>
       <AssetQueryBuilder
         filter={assetVariableQuery.filter}
         workspaces={workspaces}
@@ -40,6 +54,9 @@ export function AssetVariableQueryEditor({ datasource, query, onChange }: Props)
         globalVariableOptions={assetListDatasource.current.globalVariableOptions()}
         areDependenciesLoaded={areDependenciesLoaded}
         onChange={(event: any) => onParameterChange(event)}
+        query={assetVariableQuery}
+        handleQueryChange={ handleQueryChange }
+        complexFilterEnabled={assetFeatures.current.advancedFilter}
       ></AssetQueryBuilder>
       <FloatingError message={assetListDatasource.current.error} />
     </div>
diff --git a/src/datasources/asset/constants/constants.ts b/src/datasources/asset/constants/constants.ts
index 5b4a966b..f5e1ddee 100644
--- a/src/datasources/asset/constants/constants.ts
+++ b/src/datasources/asset/constants/constants.ts
@@ -1,4 +1,5 @@
-export enum AllFieldNames {
+export enum AllFieldNames
+{
     LOCATION = 'Location',
     WORKSPACE = 'Workspace',
     MODEL_NAME = 'ModelName',
@@ -9,3 +10,9 @@ export enum AllFieldNames {
 }
 
 export const QUERY_LIMIT = 1000;
+
+export enum QueryBuilderType
+{
+    Simple = "Simple",
+    Advanced = "Advanced",
+}
diff --git a/src/datasources/asset/data-sources/asset-summary/AssetSummaryDataSource.ts b/src/datasources/asset/data-sources/asset-summary/AssetSummaryDataSource.ts
index 839f5761..381a178a 100644
--- a/src/datasources/asset/data-sources/asset-summary/AssetSummaryDataSource.ts
+++ b/src/datasources/asset/data-sources/asset-summary/AssetSummaryDataSource.ts
@@ -5,6 +5,7 @@ import { AssetSummaryResponse } from 'datasources/asset/types/AssetSummaryQuery.
 import { AssetDataSourceBase } from '../AssetDataSourceBase';
 import { AssetDataSourceOptions, AssetQuery, AssetQueryType } from '../../types/types';
 import { assetSummaryFields } from '../../constants/AssetSummaryQuery.constants';
+import { QueryBuilderType } from 'datasources/asset/constants/constants';
 export class AssetSummaryDataSource extends AssetDataSourceBase {
     constructor(
         readonly instanceSettings: DataSourceInstanceSettings<AssetDataSourceOptions>,
@@ -18,6 +19,7 @@ export class AssetSummaryDataSource extends AssetDataSourceBase {
 
     defaultQuery = {
         type: AssetQueryType.AssetSummary,
+        queryBuilderType: QueryBuilderType.Simple,
     };
 
     async runQuery(query: AssetQuery, options: DataQueryRequest): Promise<DataFrameDTO> {
diff --git a/src/datasources/asset/data-sources/calibration-forecast/CalibrationForecastDataSource.test.ts b/src/datasources/asset/data-sources/calibration-forecast/CalibrationForecastDataSource.test.ts
index 85b3332d..39baa390 100644
--- a/src/datasources/asset/data-sources/calibration-forecast/CalibrationForecastDataSource.test.ts
+++ b/src/datasources/asset/data-sources/calibration-forecast/CalibrationForecastDataSource.test.ts
@@ -1,112 +1,123 @@
 import { BackendSrv } from "@grafana/runtime";
 import { MockProxy } from "jest-mock-extended";
-import {
-  createFetchError,
-  createFetchResponse,
-  getQueryBuilder,
-  requestMatching,
-  setupDataSource,
-} from "test/fixtures";
+import
+  {
+    createFetchError,
+    createFetchResponse,
+    getQueryBuilder,
+    requestMatching,
+    setupDataSource,
+  } from "test/fixtures";
 import { SystemMetadata } from "datasources/system/types";
 import { dateTime } from "@grafana/data";
 import { AssetCalibrationForecastKey, AssetCalibrationPropertyGroupByType, AssetCalibrationTimeBasedGroupByType, CalibrationForecastQuery, CalibrationForecastResponse, ColumnDescriptorType } from "../../types/CalibrationForecastQuery.types";
 import { CalibrationForecastDataSource } from "./CalibrationForecastDataSource";
 import { AssetQueryType, AssetType, BusType } from "../../types/types";
 import { AssetCalibrationFieldNames } from "../../constants/CalibrationForecastQuery.constants";
+import { QueryBuilderType } from "datasources/asset/constants/constants";
 
 let datastore: CalibrationForecastDataSource, backendServer: MockProxy<BackendSrv>
 
-beforeEach(() => {
-  [datastore, backendServer] = setupDataSource(CalibrationForecastDataSource);
+beforeEach( () =>
+{
+  [ datastore, backendServer ] = setupDataSource( CalibrationForecastDataSource );
 
   backendServer.fetch
-    .calledWith(requestMatching({ url: '/nisysmgmt/v1/query-systems' }))
-    .mockReturnValue(createFetchResponse({ data: fakeSystems }));
-});
+    .calledWith( requestMatching( { url: '/nisysmgmt/v1/query-systems' } ) )
+    .mockReturnValue( createFetchResponse( { data: fakeSystems } ) );
+} );
 
-const monthGroupCalibrationForecastResponseMock = (): CalibrationForecastResponse => {
+const monthGroupCalibrationForecastResponseMock = (): CalibrationForecastResponse =>
+{
   return {
     calibrationForecast: {
       columns: [
-        { name: AssetCalibrationForecastKey.Month, values: ["2022-01-01T00:00:00.0000000Z", "2022-02-01T00:00:00.0000000Z", "2022-03-01T00:00:00.0000000Z"], columnDescriptors: [{ value: "Month", type: ColumnDescriptorType.Time }] },
-        { name: "", values: [1, 0, 3], columnDescriptors: [{ value: "Assets", type: ColumnDescriptorType.Count }] }
+        { name: AssetCalibrationForecastKey.Month, values: [ "2022-01-01T00:00:00.0000000Z", "2022-02-01T00:00:00.0000000Z", "2022-03-01T00:00:00.0000000Z" ], columnDescriptors: [ { value: "Month", type: ColumnDescriptorType.Time } ] },
+        { name: "", values: [ 1, 0, 3 ], columnDescriptors: [ { value: "Assets", type: ColumnDescriptorType.Count } ] }
       ]
     }
   }
 }
 
 
-const dayGroupCalibrationForecastResponseMock = (): CalibrationForecastResponse => {
+const dayGroupCalibrationForecastResponseMock = (): CalibrationForecastResponse =>
+{
   return {
     calibrationForecast: {
       columns: [
-        { name: AssetCalibrationForecastKey.Day, values: ["2022-01-01T00:00:00.0000000Z", "2022-01-02T00:00:00.0000000Z", "2022-01-03T00:00:00.0000000Z"], columnDescriptors: [{ value: AssetCalibrationForecastKey.Day, type: ColumnDescriptorType.Time }] },
-        { name: "", values: [1, 2, 2], columnDescriptors: [{ value: "Assets", type: ColumnDescriptorType.Count }] }
+        { name: AssetCalibrationForecastKey.Day, values: [ "2022-01-01T00:00:00.0000000Z", "2022-01-02T00:00:00.0000000Z", "2022-01-03T00:00:00.0000000Z" ], columnDescriptors: [ { value: AssetCalibrationForecastKey.Day, type: ColumnDescriptorType.Time } ] },
+        { name: "", values: [ 1, 2, 2 ], columnDescriptors: [ { value: "Assets", type: ColumnDescriptorType.Count } ] }
       ]
     }
   }
 }
 
-const weekGroupCalibrationForecastResponseMock = (): CalibrationForecastResponse => {
+const weekGroupCalibrationForecastResponseMock = (): CalibrationForecastResponse =>
+{
   return {
     calibrationForecast: {
       columns: [
-        { name: AssetCalibrationForecastKey.Week, values: ["2022-01-03T00:00:00.0000000Z", "2022-01-10T00:00:00.0000000Z", "2022-01-17T00:00:00.0000000Z"], columnDescriptors: [{ value: AssetCalibrationForecastKey.Week, type: ColumnDescriptorType.Time }] },
-        { name: "", values: [1, 2, 2], columnDescriptors: [{ value: "Assets", type: ColumnDescriptorType.Count }] }
+        { name: AssetCalibrationForecastKey.Week, values: [ "2022-01-03T00:00:00.0000000Z", "2022-01-10T00:00:00.0000000Z", "2022-01-17T00:00:00.0000000Z" ], columnDescriptors: [ { value: AssetCalibrationForecastKey.Week, type: ColumnDescriptorType.Time } ] },
+        { name: "", values: [ 1, 2, 2 ], columnDescriptors: [ { value: "Assets", type: ColumnDescriptorType.Count } ] }
       ]
     }
   }
 }
 
-const weekGroupCalibrationForecastDataLinkResponseMock = (): CalibrationForecastResponse => {
+const weekGroupCalibrationForecastDataLinkResponseMock = (): CalibrationForecastResponse =>
+{
   return {
     calibrationForecast: {
       columns: [
-        { name: AssetCalibrationForecastKey.Week, values: ["2022-01-01T00:00:00.0000000Z", "2022-01-08T00:00:00.0000000Z", "2022-01-15T00:00:00.0000000Z"], columnDescriptors: [{ value: AssetCalibrationForecastKey.Week, type: ColumnDescriptorType.Time }] },
-        { name: "", values: [3, 2, 2], columnDescriptors: [{ value: "Assets", type: ColumnDescriptorType.Count }] }
+        { name: AssetCalibrationForecastKey.Week, values: [ "2022-01-01T00:00:00.0000000Z", "2022-01-08T00:00:00.0000000Z", "2022-01-15T00:00:00.0000000Z" ], columnDescriptors: [ { value: AssetCalibrationForecastKey.Week, type: ColumnDescriptorType.Time } ] },
+        { name: "", values: [ 3, 2, 2 ], columnDescriptors: [ { value: "Assets", type: ColumnDescriptorType.Count } ] }
       ]
     }
   }
 }
 
 
-const locationGroupCalibrationForecastResponseMock = (): CalibrationForecastResponse => {
+const locationGroupCalibrationForecastResponseMock = (): CalibrationForecastResponse =>
+{
   return {
     calibrationForecast: {
       columns: [
-        { name: "", values: [1], columnDescriptors: [{ value: "Location1", type: ColumnDescriptorType.StringValue }] },
-        { name: "", values: [2], columnDescriptors: [{ value: "Location2", type: ColumnDescriptorType.StringValue }] },
-        { name: "", values: [3], columnDescriptors: [{ value: "Location3", type: ColumnDescriptorType.StringValue }] }
+        { name: "", values: [ 1 ], columnDescriptors: [ { value: "Location1", type: ColumnDescriptorType.StringValue } ] },
+        { name: "", values: [ 2 ], columnDescriptors: [ { value: "Location2", type: ColumnDescriptorType.StringValue } ] },
+        { name: "", values: [ 3 ], columnDescriptors: [ { value: "Location3", type: ColumnDescriptorType.StringValue } ] }
       ]
     }
   }
 }
 
-const minionIdLocationGroupCalibrationForecastResponseMock = (): CalibrationForecastResponse => {
+const minionIdLocationGroupCalibrationForecastResponseMock = (): CalibrationForecastResponse =>
+{
   return {
     calibrationForecast: {
       columns: [
-        { name: "", values: [1], columnDescriptors: [{ value: "Minion1", type: ColumnDescriptorType.MinionId }] },
-        { name: "", values: [2], columnDescriptors: [{ value: "Minion2", type: ColumnDescriptorType.MinionId }] },
-        { name: "", values: [3], columnDescriptors: [{ value: "Minion3", type: ColumnDescriptorType.MinionId }] }
+        { name: "", values: [ 1 ], columnDescriptors: [ { value: "Minion1", type: ColumnDescriptorType.MinionId } ] },
+        { name: "", values: [ 2 ], columnDescriptors: [ { value: "Minion2", type: ColumnDescriptorType.MinionId } ] },
+        { name: "", values: [ 3 ], columnDescriptors: [ { value: "Minion3", type: ColumnDescriptorType.MinionId } ] }
       ]
     }
   }
 }
 
 
-const modelGroupCalibrationForecastResponseMock = (): CalibrationForecastResponse => {
+const modelGroupCalibrationForecastResponseMock = (): CalibrationForecastResponse =>
+{
   return {
     calibrationForecast: {
       columns: [
-        { name: "", values: [1], columnDescriptors: [{ value: "Model1", type: ColumnDescriptorType.StringValue }] },
-        { name: "", values: [2], columnDescriptors: [{ value: "Model2", type: ColumnDescriptorType.StringValue }] }
+        { name: "", values: [ 1 ], columnDescriptors: [ { value: "Model1", type: ColumnDescriptorType.StringValue } ] },
+        { name: "", values: [ 2 ], columnDescriptors: [ { value: "Model2", type: ColumnDescriptorType.StringValue } ] }
       ]
     }
   }
 }
 
-const emptyGroupCalibrationForecastResponseMock = (): CalibrationForecastResponse => {
+const emptyGroupCalibrationForecastResponseMock = (): CalibrationForecastResponse =>
+{
   return {
     calibrationForecast: {
       columns: [
@@ -115,132 +126,143 @@ const emptyGroupCalibrationForecastResponseMock = (): CalibrationForecastRespons
   }
 }
 
-const modelLocationGroupCalibrationForecastResponseMock = (): CalibrationForecastResponse => {
+const modelLocationGroupCalibrationForecastResponseMock = (): CalibrationForecastResponse =>
+{
   return {
     calibrationForecast: {
       columns: [
-        { name: "", values: [1], columnDescriptors: [{ value: "Model1", type: ColumnDescriptorType.StringValue }, { value: "Location1", type: ColumnDescriptorType.StringValue }] },
-        { name: "", values: [2], columnDescriptors: [{ value: "Model2", type: ColumnDescriptorType.StringValue }, { value: "Location1", type: ColumnDescriptorType.StringValue }] }
+        { name: "", values: [ 1 ], columnDescriptors: [ { value: "Model1", type: ColumnDescriptorType.StringValue }, { value: "Location1", type: ColumnDescriptorType.StringValue } ] },
+        { name: "", values: [ 2 ], columnDescriptors: [ { value: "Model2", type: ColumnDescriptorType.StringValue }, { value: "Location1", type: ColumnDescriptorType.StringValue } ] }
       ]
     }
   }
 }
 
-const monthLocationGroupCalibrationForecastResponseMock = (): CalibrationForecastResponse => {
+const monthLocationGroupCalibrationForecastResponseMock = (): CalibrationForecastResponse =>
+{
   return {
     calibrationForecast: {
       columns: [
-        { name: "", values: ["2022-01-01T00:00:00.0000000Z", "2022-02-01T00:00:00.0000000Z", "2022-03-01T00:00:00.0000000Z"], columnDescriptors: [{ value: "Month", type: ColumnDescriptorType.Time }] },
-        { name: "", values: [1, 2, 3], columnDescriptors: [{ value: "Location1", type: ColumnDescriptorType.StringValue }] },
-        { name: "", values: [2, 4, 1], columnDescriptors: [{ value: "Location2", type: ColumnDescriptorType.StringValue }] },
-        { name: "", values: [4, 3, 1], columnDescriptors: [{ value: "Location3", type: ColumnDescriptorType.StringValue }] }
+        { name: "", values: [ "2022-01-01T00:00:00.0000000Z", "2022-02-01T00:00:00.0000000Z", "2022-03-01T00:00:00.0000000Z" ], columnDescriptors: [ { value: "Month", type: ColumnDescriptorType.Time } ] },
+        { name: "", values: [ 1, 2, 3 ], columnDescriptors: [ { value: "Location1", type: ColumnDescriptorType.StringValue } ] },
+        { name: "", values: [ 2, 4, 1 ], columnDescriptors: [ { value: "Location2", type: ColumnDescriptorType.StringValue } ] },
+        { name: "", values: [ 4, 3, 1 ], columnDescriptors: [ { value: "Location3", type: ColumnDescriptorType.StringValue } ] }
       ]
     }
   }
 }
 
-const workspaceGroupCalibrationForecastResponseMock = (): CalibrationForecastResponse => {
+const workspaceGroupCalibrationForecastResponseMock = (): CalibrationForecastResponse =>
+{
   return {
     calibrationForecast: {
       columns: [
-        { name: "", values: [1], columnDescriptors: [{ value: "Workspace1", type: ColumnDescriptorType.WorkspaceId }] },
-        { name: "", values: [2], columnDescriptors: [{ value: "Workspace1", type: ColumnDescriptorType.WorkspaceId }] }
+        { name: "", values: [ 1 ], columnDescriptors: [ { value: "Workspace1", type: ColumnDescriptorType.WorkspaceId } ] },
+        { name: "", values: [ 2 ], columnDescriptors: [ { value: "Workspace1", type: ColumnDescriptorType.WorkspaceId } ] }
       ]
     }
   }
 }
 
-const vendorGroupCalibrationForecastResponseMock = (): CalibrationForecastResponse => {
+const vendorGroupCalibrationForecastResponseMock = (): CalibrationForecastResponse =>
+{
   return {
     calibrationForecast: {
       columns: [
-        { name: "", values: [1], columnDescriptors: [{ value: "Vendor1", type: ColumnDescriptorType.StringValue }] },
-        { name: "", values: [2], columnDescriptors: [{ value: "Vendor2", type: ColumnDescriptorType.StringValue }] }
+        { name: "", values: [ 1 ], columnDescriptors: [ { value: "Vendor1", type: ColumnDescriptorType.StringValue } ] },
+        { name: "", values: [ 2 ], columnDescriptors: [ { value: "Vendor2", type: ColumnDescriptorType.StringValue } ] }
       ]
     }
   }
 }
 
-const assetTypeGroupCalibrationForecastResponseMock = (): CalibrationForecastResponse => {
+const assetTypeGroupCalibrationForecastResponseMock = (): CalibrationForecastResponse =>
+{
   return {
     calibrationForecast: {
       columns: [
-        { name: "", values: [1], columnDescriptors: [{ value: AssetType.GENERIC, type: ColumnDescriptorType.AssetType }] },
-        { name: "", values: [2], columnDescriptors: [{ value: AssetType.DEVICE_UNDER_TEST, type: ColumnDescriptorType.AssetType }] }
+        { name: "", values: [ 1 ], columnDescriptors: [ { value: AssetType.GENERIC, type: ColumnDescriptorType.AssetType } ] },
+        { name: "", values: [ 2 ], columnDescriptors: [ { value: AssetType.DEVICE_UNDER_TEST, type: ColumnDescriptorType.AssetType } ] }
       ]
     }
   }
 }
 
-const busTypeGroupCalibrationForecastResponseMock = (): CalibrationForecastResponse => {
+const busTypeGroupCalibrationForecastResponseMock = (): CalibrationForecastResponse =>
+{
   return {
     calibrationForecast: {
       columns: [
-        { name: "", values: [1], columnDescriptors: [{ value: BusType.BUILT_IN_SYSTEM, type: ColumnDescriptorType.BusType }] },
-        { name: "", values: [2], columnDescriptors: [{ value: BusType.FIRE_WIRE, type: ColumnDescriptorType.BusType }] }
+        { name: "", values: [ 1 ], columnDescriptors: [ { value: BusType.BUILT_IN_SYSTEM, type: ColumnDescriptorType.BusType } ] },
+        { name: "", values: [ 2 ], columnDescriptors: [ { value: BusType.FIRE_WIRE, type: ColumnDescriptorType.BusType } ] }
       ]
     }
   }
 }
 
-const modelWorkspaceGroupCalibrationForecastResponseMock = (): CalibrationForecastResponse => {
+const modelWorkspaceGroupCalibrationForecastResponseMock = (): CalibrationForecastResponse =>
+{
   return {
     calibrationForecast: {
       columns: [
-        { name: "", values: [1], columnDescriptors: [{ value: "Model1", type: ColumnDescriptorType.StringValue }, { value: "Workspace1", type: ColumnDescriptorType.WorkspaceId }] },
-        { name: "", values: [2], columnDescriptors: [{ value: "Model2", type: ColumnDescriptorType.StringValue }, { value: "Workspace1", type: ColumnDescriptorType.WorkspaceId }] }
+        { name: "", values: [ 1 ], columnDescriptors: [ { value: "Model1", type: ColumnDescriptorType.StringValue }, { value: "Workspace1", type: ColumnDescriptorType.WorkspaceId } ] },
+        { name: "", values: [ 2 ], columnDescriptors: [ { value: "Model2", type: ColumnDescriptorType.StringValue }, { value: "Workspace1", type: ColumnDescriptorType.WorkspaceId } ] }
       ]
     }
   }
 }
 
-const monthWorkspaceGroupCalibrationForecastResponseMock = (): CalibrationForecastResponse => {
+const monthWorkspaceGroupCalibrationForecastResponseMock = (): CalibrationForecastResponse =>
+{
   return {
     calibrationForecast: {
       columns: [
-        { name: "", values: ["2022-01-01T00:00:00.0000000Z", "2022-02-01T00:00:00.0000000Z", "2022-03-01T00:00:00.0000000Z"], columnDescriptors: [{ value: "Month", type: ColumnDescriptorType.Time }] },
-        { name: "", values: [1, 2, 3], columnDescriptors: [{ value: "Workspace1", type: ColumnDescriptorType.WorkspaceId }] },
-        { name: "", values: [2, 4, 1], columnDescriptors: [{ value: "Workspace2", type: ColumnDescriptorType.WorkspaceId }] },
-        { name: "", values: [4, 3, 1], columnDescriptors: [{ value: "Workspace3", type: ColumnDescriptorType.WorkspaceId }] }
+        { name: "", values: [ "2022-01-01T00:00:00.0000000Z", "2022-02-01T00:00:00.0000000Z", "2022-03-01T00:00:00.0000000Z" ], columnDescriptors: [ { value: "Month", type: ColumnDescriptorType.Time } ] },
+        { name: "", values: [ 1, 2, 3 ], columnDescriptors: [ { value: "Workspace1", type: ColumnDescriptorType.WorkspaceId } ] },
+        { name: "", values: [ 2, 4, 1 ], columnDescriptors: [ { value: "Workspace2", type: ColumnDescriptorType.WorkspaceId } ] },
+        { name: "", values: [ 4, 3, 1 ], columnDescriptors: [ { value: "Workspace3", type: ColumnDescriptorType.WorkspaceId } ] }
       ]
     }
   }
 }
 
-const monthVendorGroupCalibrationForecastResponseMock = (): CalibrationForecastResponse => {
+const monthVendorGroupCalibrationForecastResponseMock = (): CalibrationForecastResponse =>
+{
   return {
     calibrationForecast: {
       columns: [
-        { name: "", values: ["2022-01-01T00:00:00.0000000Z", "2022-02-01T00:00:00.0000000Z", "2022-03-01T00:00:00.0000000Z"], columnDescriptors: [{ value: "Month", type: ColumnDescriptorType.Time }] },
-        { name: "", values: [1, 2, 3], columnDescriptors: [{ value: "Vendor1", type: ColumnDescriptorType.StringValue }] },
-        { name: "", values: [2, 4, 1], columnDescriptors: [{ value: "Vendor2", type: ColumnDescriptorType.StringValue }] },
-        { name: "", values: [4, 3, 1], columnDescriptors: [{ value: "Vendor3", type: ColumnDescriptorType.StringValue }] }
+        { name: "", values: [ "2022-01-01T00:00:00.0000000Z", "2022-02-01T00:00:00.0000000Z", "2022-03-01T00:00:00.0000000Z" ], columnDescriptors: [ { value: "Month", type: ColumnDescriptorType.Time } ] },
+        { name: "", values: [ 1, 2, 3 ], columnDescriptors: [ { value: "Vendor1", type: ColumnDescriptorType.StringValue } ] },
+        { name: "", values: [ 2, 4, 1 ], columnDescriptors: [ { value: "Vendor2", type: ColumnDescriptorType.StringValue } ] },
+        { name: "", values: [ 4, 3, 1 ], columnDescriptors: [ { value: "Vendor3", type: ColumnDescriptorType.StringValue } ] }
       ]
     }
   }
 }
 
-const monthAssetTypeGroupCalibrationForecastResponseMock = (): CalibrationForecastResponse => {
+const monthAssetTypeGroupCalibrationForecastResponseMock = (): CalibrationForecastResponse =>
+{
   return {
     calibrationForecast: {
       columns: [
-        { name: "", values: ["2022-01-01T00:00:00.0000000Z", "2022-02-01T00:00:00.0000000Z", "2022-03-01T00:00:00.0000000Z"], columnDescriptors: [{ value: "Month", type: ColumnDescriptorType.Time }] },
-        { name: "", values: [1, 2, 3], columnDescriptors: [{ value: AssetType.DEVICE_UNDER_TEST, type: ColumnDescriptorType.AssetType }] },
-        { name: "", values: [2, 4, 1], columnDescriptors: [{ value: AssetType.FIXTURE, type: ColumnDescriptorType.AssetType }] },
-        { name: "", values: [4, 3, 1], columnDescriptors: [{ value: AssetType.GENERIC, type: ColumnDescriptorType.AssetType }] }
+        { name: "", values: [ "2022-01-01T00:00:00.0000000Z", "2022-02-01T00:00:00.0000000Z", "2022-03-01T00:00:00.0000000Z" ], columnDescriptors: [ { value: "Month", type: ColumnDescriptorType.Time } ] },
+        { name: "", values: [ 1, 2, 3 ], columnDescriptors: [ { value: AssetType.DEVICE_UNDER_TEST, type: ColumnDescriptorType.AssetType } ] },
+        { name: "", values: [ 2, 4, 1 ], columnDescriptors: [ { value: AssetType.FIXTURE, type: ColumnDescriptorType.AssetType } ] },
+        { name: "", values: [ 4, 3, 1 ], columnDescriptors: [ { value: AssetType.GENERIC, type: ColumnDescriptorType.AssetType } ] }
       ]
     }
   }
 }
 
-const monthBusTypeGroupCalibrationForecastResponseMock = (): CalibrationForecastResponse => {
+const monthBusTypeGroupCalibrationForecastResponseMock = (): CalibrationForecastResponse =>
+{
   return {
     calibrationForecast: {
       columns: [
-        { name: "", values: ["2022-01-01T00:00:00.0000000Z", "2022-02-01T00:00:00.0000000Z", "2022-03-01T00:00:00.0000000Z"], columnDescriptors: [{ value: "Month", type: ColumnDescriptorType.Time }] },
-        { name: "", values: [1, 2, 3], columnDescriptors: [{ value: BusType.BUILT_IN_SYSTEM, type: ColumnDescriptorType.BusType }] },
-        { name: "", values: [2, 4, 1], columnDescriptors: [{ value: BusType.ACCESSORY, type: ColumnDescriptorType.BusType }] },
-        { name: "", values: [4, 3, 1], columnDescriptors: [{ value: BusType.SERIAL, type: ColumnDescriptorType.BusType }] }
+        { name: "", values: [ "2022-01-01T00:00:00.0000000Z", "2022-02-01T00:00:00.0000000Z", "2022-03-01T00:00:00.0000000Z" ], columnDescriptors: [ { value: "Month", type: ColumnDescriptorType.Time } ] },
+        { name: "", values: [ 1, 2, 3 ], columnDescriptors: [ { value: BusType.BUILT_IN_SYSTEM, type: ColumnDescriptorType.BusType } ] },
+        { name: "", values: [ 2, 4, 1 ], columnDescriptors: [ { value: BusType.ACCESSORY, type: ColumnDescriptorType.BusType } ] },
+        { name: "", values: [ 4, 3, 1 ], columnDescriptors: [ { value: BusType.SERIAL, type: ColumnDescriptorType.BusType } ] }
       ]
     }
   }
@@ -248,68 +270,78 @@ const monthBusTypeGroupCalibrationForecastResponseMock = (): CalibrationForecast
 
 const monthBasedCalibrationForecastQueryMock: CalibrationForecastQuery = {
   refId: '',
-  groupBy: [AssetCalibrationTimeBasedGroupByType.Month],
-  type: AssetQueryType.CalibrationForecast
+  groupBy: [ AssetCalibrationTimeBasedGroupByType.Month ],
+  type: AssetQueryType.CalibrationForecast,
+  queryBuilderType: QueryBuilderType.Simple
 }
 
 const weekBasedCalibrationForecastQueryMock: CalibrationForecastQuery = {
   refId: '',
-  groupBy: [AssetCalibrationTimeBasedGroupByType.Week],
-  type: AssetQueryType.CalibrationForecast
+  groupBy: [ AssetCalibrationTimeBasedGroupByType.Week ],
+  type: AssetQueryType.CalibrationForecast,
+  queryBuilderType: QueryBuilderType.Simple
 }
 
 const dayBasedCalibrationForecastQueryMock: CalibrationForecastQuery = {
   refId: '',
-  groupBy: [AssetCalibrationTimeBasedGroupByType.Day],
-  type: AssetQueryType.CalibrationForecast
+  groupBy: [ AssetCalibrationTimeBasedGroupByType.Day ],
+  type: AssetQueryType.CalibrationForecast,
+  queryBuilderType: QueryBuilderType.Simple
 }
 
 const locationBasedCalibrationForecastQueryMock: CalibrationForecastQuery = {
   refId: '',
-  groupBy: [AssetCalibrationPropertyGroupByType.Location],
-  type: AssetQueryType.CalibrationForecast
+  groupBy: [ AssetCalibrationPropertyGroupByType.Location ],
+  type: AssetQueryType.CalibrationForecast,
+  queryBuilderType: QueryBuilderType.Simple
 }
 
 const modelBasedCalibrationForecastQueryMock: CalibrationForecastQuery = {
   refId: '',
-  groupBy: [AssetCalibrationPropertyGroupByType.Model],
-  type: AssetQueryType.CalibrationForecast
+  groupBy: [ AssetCalibrationPropertyGroupByType.Model ],
+  type: AssetQueryType.CalibrationForecast,
+  queryBuilderType: QueryBuilderType.Simple
 }
 
 const workspaceBasedCalibrationForecastQueryMock: CalibrationForecastQuery = {
   refId: '',
-  groupBy: [AssetCalibrationPropertyGroupByType.Workspace],
-  type: AssetQueryType.CalibrationForecast
+  groupBy: [ AssetCalibrationPropertyGroupByType.Workspace ],
+  type: AssetQueryType.CalibrationForecast,
+  queryBuilderType: QueryBuilderType.Simple
 }
 
 const modelLocationBasedCalibrationForecastQueryMock: CalibrationForecastQuery = {
   refId: '',
-  groupBy: [AssetCalibrationPropertyGroupByType.Model, AssetCalibrationPropertyGroupByType.Location],
-  type: AssetQueryType.CalibrationForecast
+  groupBy: [ AssetCalibrationPropertyGroupByType.Model, AssetCalibrationPropertyGroupByType.Location ],
+  type: AssetQueryType.CalibrationForecast,
+  queryBuilderType: QueryBuilderType.Simple
 }
 
 const monthLocationBasedCalibrationForecastQueryMock: CalibrationForecastQuery = {
   refId: '',
-  groupBy: [AssetCalibrationTimeBasedGroupByType.Month, AssetCalibrationPropertyGroupByType.Location],
-  type: AssetQueryType.CalibrationForecast
+  groupBy: [ AssetCalibrationTimeBasedGroupByType.Month, AssetCalibrationPropertyGroupByType.Location ],
+  type: AssetQueryType.CalibrationForecast,
+  queryBuilderType: QueryBuilderType.Simple
 }
 
 const modelWorkspaceBasedCalibrationForecastQueryMock: CalibrationForecastQuery = {
   refId: '',
-  groupBy: [AssetCalibrationPropertyGroupByType.Model, AssetCalibrationPropertyGroupByType.Workspace],
-  type: AssetQueryType.CalibrationForecast
+  groupBy: [ AssetCalibrationPropertyGroupByType.Model, AssetCalibrationPropertyGroupByType.Workspace ],
+  type: AssetQueryType.CalibrationForecast,
+  queryBuilderType: QueryBuilderType.Simple
 }
 
 const monthWorkspaceBasedCalibrationForecastQueryMock: CalibrationForecastQuery = {
   refId: '',
-  groupBy: [AssetCalibrationTimeBasedGroupByType.Month, AssetCalibrationPropertyGroupByType.Workspace],
-  type: AssetQueryType.CalibrationForecast
+  groupBy: [ AssetCalibrationTimeBasedGroupByType.Month, AssetCalibrationPropertyGroupByType.Workspace ],
+  type: AssetQueryType.CalibrationForecast,
+  queryBuilderType: QueryBuilderType.Simple
 }
 
-const buildCalibrationForecastQuery = getQueryBuilder<CalibrationForecastQuery>()({
+const buildCalibrationForecastQuery = getQueryBuilder<CalibrationForecastQuery>()( {
   refId: '',
   groupBy: []
-});
+} );
 
 const fakeSystems: SystemMetadata[] = [
   {
@@ -326,390 +358,431 @@ const fakeSystems: SystemMetadata[] = [
   },
 ];
 
-describe('testDatasource', () => {
-  test('returns success', async () => {
+describe( 'testDatasource', () =>
+{
+  test( 'returns success', async () =>
+  {
     backendServer.fetch
-      .calledWith(requestMatching({ url: '/niapm/v1/assets?take=1' }))
-      .mockReturnValue(createFetchResponse(25));
+      .calledWith( requestMatching( { url: '/niapm/v1/assets?take=1' } ) )
+      .mockReturnValue( createFetchResponse( 25 ) );
 
     const result = await datastore.testDatasource();
 
-    expect(result.status).toEqual('success');
-  });
+    expect( result.status ).toEqual( 'success' );
+  } );
 
-  test('bubbles up exception', async () => {
+  test( 'bubbles up exception', async () =>
+  {
     backendServer.fetch
-      .calledWith(requestMatching({ url: '/niapm/v1/assets?take=1' }))
-      .mockReturnValue(createFetchError(400));
+      .calledWith( requestMatching( { url: '/niapm/v1/assets?take=1' } ) )
+      .mockReturnValue( createFetchError( 400 ) );
 
-    await expect(datastore.testDatasource()).rejects.toThrow('Request to url "/niapm/v1/assets?take=1" failed with status code: 400. Error message: "Error"');
-  });
-})
+    await expect( datastore.testDatasource() ).rejects.toThrow( 'Request to url "/niapm/v1/assets?take=1" failed with status code: 400. Error message: "Error"' );
+  } );
+} )
 
-describe('queries', () => {
-  test('asset calibration forecast with month groupBy', async () => {
+describe( 'queries', () =>
+{
+  test( 'asset calibration forecast with month groupBy', async () =>
+  {
     backendServer.fetch
-      .calledWith(requestMatching({ url: '/niapm/v1/assets/calibration-forecast' }))
-      .mockReturnValue(createFetchResponse(monthGroupCalibrationForecastResponseMock() as CalibrationForecastResponse))
+      .calledWith( requestMatching( { url: '/niapm/v1/assets/calibration-forecast' } ) )
+      .mockReturnValue( createFetchResponse( monthGroupCalibrationForecastResponseMock() as CalibrationForecastResponse ) )
 
-    const result = await datastore.query(buildCalibrationForecastQuery(monthBasedCalibrationForecastQueryMock))
+    const result = await datastore.query( buildCalibrationForecastQuery( monthBasedCalibrationForecastQueryMock ) )
 
-    expect(result.data).toMatchSnapshot()
-  })
+    expect( result.data ).toMatchSnapshot()
+  } )
 
-  test('asset calibration forecast with week groupBy', async () => {
+  test( 'asset calibration forecast with week groupBy', async () =>
+  {
     backendServer.fetch
-      .calledWith(requestMatching({ url: '/niapm/v1/assets/calibration-forecast' }))
-      .mockReturnValue(createFetchResponse(weekGroupCalibrationForecastResponseMock() as CalibrationForecastResponse))
+      .calledWith( requestMatching( { url: '/niapm/v1/assets/calibration-forecast' } ) )
+      .mockReturnValue( createFetchResponse( weekGroupCalibrationForecastResponseMock() as CalibrationForecastResponse ) )
 
-    const result = await datastore.query(buildCalibrationForecastQuery(weekBasedCalibrationForecastQueryMock))
+    const result = await datastore.query( buildCalibrationForecastQuery( weekBasedCalibrationForecastQueryMock ) )
 
-    expect(result.data).toMatchSnapshot()
-  })
+    expect( result.data ).toMatchSnapshot()
+  } )
 
-  test('asset calibration forecast with day groupBy', async () => {
+  test( 'asset calibration forecast with day groupBy', async () =>
+  {
     backendServer.fetch
-      .calledWith(requestMatching({ url: '/niapm/v1/assets/calibration-forecast' }))
-      .mockReturnValue(createFetchResponse(dayGroupCalibrationForecastResponseMock() as CalibrationForecastResponse))
+      .calledWith( requestMatching( { url: '/niapm/v1/assets/calibration-forecast' } ) )
+      .mockReturnValue( createFetchResponse( dayGroupCalibrationForecastResponseMock() as CalibrationForecastResponse ) )
 
-    const result = await datastore.query(buildCalibrationForecastQuery(dayBasedCalibrationForecastQueryMock))
+    const result = await datastore.query( buildCalibrationForecastQuery( dayBasedCalibrationForecastQueryMock ) )
 
-    expect(result.data).toMatchSnapshot()
-  })
+    expect( result.data ).toMatchSnapshot()
+  } )
 
-  test('calibration forecast with location groupBy', async () => {
+  test( 'calibration forecast with location groupBy', async () =>
+  {
     backendServer.fetch
-      .calledWith(requestMatching({ url: '/niapm/v1/assets/calibration-forecast' }))
-      .mockReturnValue(createFetchResponse(locationGroupCalibrationForecastResponseMock() as CalibrationForecastResponse))
+      .calledWith( requestMatching( { url: '/niapm/v1/assets/calibration-forecast' } ) )
+      .mockReturnValue( createFetchResponse( locationGroupCalibrationForecastResponseMock() as CalibrationForecastResponse ) )
 
-    const result = await datastore.query(buildCalibrationForecastQuery(locationBasedCalibrationForecastQueryMock))
+    const result = await datastore.query( buildCalibrationForecastQuery( locationBasedCalibrationForecastQueryMock ) )
 
-    expect(result.data).toMatchSnapshot()
-  })
+    expect( result.data ).toMatchSnapshot()
+  } )
 
-  test('calibration forecast with minion ID location groupBy', async () => {
+  test( 'calibration forecast with minion ID location groupBy', async () =>
+  {
     backendServer.fetch
-      .calledWith(requestMatching({ url: '/niapm/v1/assets/calibration-forecast' }))
-      .mockReturnValue(createFetchResponse(minionIdLocationGroupCalibrationForecastResponseMock() as CalibrationForecastResponse))
+      .calledWith( requestMatching( { url: '/niapm/v1/assets/calibration-forecast' } ) )
+      .mockReturnValue( createFetchResponse( minionIdLocationGroupCalibrationForecastResponseMock() as CalibrationForecastResponse ) )
 
-    const result = await datastore.query(buildCalibrationForecastQuery(locationBasedCalibrationForecastQueryMock))
+    const result = await datastore.query( buildCalibrationForecastQuery( locationBasedCalibrationForecastQueryMock ) )
 
-    expect(result.data).toMatchSnapshot()
-  })
+    expect( result.data ).toMatchSnapshot()
+  } )
 
-  test('calibration forecast with model groupBy', async () => {
+  test( 'calibration forecast with model groupBy', async () =>
+  {
     backendServer.fetch
-      .calledWith(requestMatching({ url: '/niapm/v1/assets/calibration-forecast' }))
-      .mockReturnValue(createFetchResponse(modelGroupCalibrationForecastResponseMock() as CalibrationForecastResponse))
+      .calledWith( requestMatching( { url: '/niapm/v1/assets/calibration-forecast' } ) )
+      .mockReturnValue( createFetchResponse( modelGroupCalibrationForecastResponseMock() as CalibrationForecastResponse ) )
 
-    const result = await datastore.query(buildCalibrationForecastQuery(modelBasedCalibrationForecastQueryMock))
+    const result = await datastore.query( buildCalibrationForecastQuery( modelBasedCalibrationForecastQueryMock ) )
 
-    expect(result.data).toMatchSnapshot();
-  })
+    expect( result.data ).toMatchSnapshot();
+  } )
 
-  test('calibration forecast with model and location groupBy', async () => {
+  test( 'calibration forecast with model and location groupBy', async () =>
+  {
     backendServer.fetch
-      .calledWith(requestMatching({ url: '/niapm/v1/assets/calibration-forecast' }))
-      .mockReturnValue(createFetchResponse(modelLocationGroupCalibrationForecastResponseMock() as CalibrationForecastResponse))
+      .calledWith( requestMatching( { url: '/niapm/v1/assets/calibration-forecast' } ) )
+      .mockReturnValue( createFetchResponse( modelLocationGroupCalibrationForecastResponseMock() as CalibrationForecastResponse ) )
 
-    const result = await datastore.query(buildCalibrationForecastQuery(modelLocationBasedCalibrationForecastQueryMock))
+    const result = await datastore.query( buildCalibrationForecastQuery( modelLocationBasedCalibrationForecastQueryMock ) )
 
-    expect(result.data).toMatchSnapshot();
-  })
+    expect( result.data ).toMatchSnapshot();
+  } )
 
-  test('calibration forecast with month and location groupBy', async () => {
+  test( 'calibration forecast with month and location groupBy', async () =>
+  {
     backendServer.fetch
-      .calledWith(requestMatching({ url: '/niapm/v1/assets/calibration-forecast' }))
-      .mockReturnValue(createFetchResponse(monthLocationGroupCalibrationForecastResponseMock() as CalibrationForecastResponse))
+      .calledWith( requestMatching( { url: '/niapm/v1/assets/calibration-forecast' } ) )
+      .mockReturnValue( createFetchResponse( monthLocationGroupCalibrationForecastResponseMock() as CalibrationForecastResponse ) )
 
-    const result = await datastore.query(buildCalibrationForecastQuery(monthLocationBasedCalibrationForecastQueryMock))
+    const result = await datastore.query( buildCalibrationForecastQuery( monthLocationBasedCalibrationForecastQueryMock ) )
 
-    expect(result.data).toMatchSnapshot();
-  })
+    expect( result.data ).toMatchSnapshot();
+  } )
 
-  test('calibration forecast with workspace groupBy', async () => {
+  test( 'calibration forecast with workspace groupBy', async () =>
+  {
     backendServer.fetch
-      .calledWith(requestMatching({ url: '/niapm/v1/assets/calibration-forecast' }))
-      .mockReturnValue(createFetchResponse(workspaceGroupCalibrationForecastResponseMock() as CalibrationForecastResponse))
+      .calledWith( requestMatching( { url: '/niapm/v1/assets/calibration-forecast' } ) )
+      .mockReturnValue( createFetchResponse( workspaceGroupCalibrationForecastResponseMock() as CalibrationForecastResponse ) )
 
-    const result = await datastore.query(buildCalibrationForecastQuery(workspaceBasedCalibrationForecastQueryMock))
+    const result = await datastore.query( buildCalibrationForecastQuery( workspaceBasedCalibrationForecastQueryMock ) )
 
-    expect(result.data).toMatchSnapshot();
-  })
+    expect( result.data ).toMatchSnapshot();
+  } )
 
-  test('calibration forecast with model and workspace groupBy', async () => {
+  test( 'calibration forecast with model and workspace groupBy', async () =>
+  {
     backendServer.fetch
-      .calledWith(requestMatching({ url: '/niapm/v1/assets/calibration-forecast' }))
-      .mockReturnValue(createFetchResponse(modelWorkspaceGroupCalibrationForecastResponseMock() as CalibrationForecastResponse))
+      .calledWith( requestMatching( { url: '/niapm/v1/assets/calibration-forecast' } ) )
+      .mockReturnValue( createFetchResponse( modelWorkspaceGroupCalibrationForecastResponseMock() as CalibrationForecastResponse ) )
 
-    const result = await datastore.query(buildCalibrationForecastQuery(modelWorkspaceBasedCalibrationForecastQueryMock))
+    const result = await datastore.query( buildCalibrationForecastQuery( modelWorkspaceBasedCalibrationForecastQueryMock ) )
 
-    expect(result.data).toMatchSnapshot();
-  })
+    expect( result.data ).toMatchSnapshot();
+  } )
 
-  test('calibration forecast with month and workspace groupBy', async () => {
+  test( 'calibration forecast with month and workspace groupBy', async () =>
+  {
     backendServer.fetch
-      .calledWith(requestMatching({ url: '/niapm/v1/assets/calibration-forecast' }))
-      .mockReturnValue(createFetchResponse(monthWorkspaceGroupCalibrationForecastResponseMock() as CalibrationForecastResponse))
+      .calledWith( requestMatching( { url: '/niapm/v1/assets/calibration-forecast' } ) )
+      .mockReturnValue( createFetchResponse( monthWorkspaceGroupCalibrationForecastResponseMock() as CalibrationForecastResponse ) )
 
-    const result = await datastore.query(buildCalibrationForecastQuery(monthWorkspaceBasedCalibrationForecastQueryMock))
+    const result = await datastore.query( buildCalibrationForecastQuery( monthWorkspaceBasedCalibrationForecastQueryMock ) )
 
-    expect(result.data).toMatchSnapshot()
-  })
+    expect( result.data ).toMatchSnapshot()
+  } )
 
-  test('calibration forecast with vendor groupBy', async () => {
+  test( 'calibration forecast with vendor groupBy', async () =>
+  {
     backendServer.fetch
-      .calledWith(requestMatching({ url: '/niapm/v1/assets/calibration-forecast' }))
-      .mockReturnValue(createFetchResponse(vendorGroupCalibrationForecastResponseMock() as CalibrationForecastResponse))
+      .calledWith( requestMatching( { url: '/niapm/v1/assets/calibration-forecast' } ) )
+      .mockReturnValue( createFetchResponse( vendorGroupCalibrationForecastResponseMock() as CalibrationForecastResponse ) )
 
-    const result = await datastore.query(buildCalibrationForecastQuery({ type: AssetQueryType.CalibrationForecast, groupBy: [AssetCalibrationPropertyGroupByType.Vendor] }))
+    const result = await datastore.query( buildCalibrationForecastQuery( { type: AssetQueryType.CalibrationForecast, groupBy: [ AssetCalibrationPropertyGroupByType.Vendor ], queryBuilderType: QueryBuilderType.Simple } ) )
 
-    expect(result.data).toMatchSnapshot();
-  })
+    expect( result.data ).toMatchSnapshot();
+  } )
 
-  test('calibration forecast with month and vendor groupBy', async () => {
+  test( 'calibration forecast with month and vendor groupBy', async () =>
+  {
     backendServer.fetch
-      .calledWith(requestMatching({ url: '/niapm/v1/assets/calibration-forecast' }))
-      .mockReturnValue(createFetchResponse(monthVendorGroupCalibrationForecastResponseMock() as CalibrationForecastResponse))
+      .calledWith( requestMatching( { url: '/niapm/v1/assets/calibration-forecast' } ) )
+      .mockReturnValue( createFetchResponse( monthVendorGroupCalibrationForecastResponseMock() as CalibrationForecastResponse ) )
 
-    const result = await datastore.query(buildCalibrationForecastQuery({
+    const result = await datastore.query( buildCalibrationForecastQuery( {
       type: AssetQueryType.CalibrationForecast,
-      groupBy: [AssetCalibrationTimeBasedGroupByType.Month, AssetCalibrationPropertyGroupByType.Vendor]
-    }));
+      groupBy: [ AssetCalibrationTimeBasedGroupByType.Month, AssetCalibrationPropertyGroupByType.Vendor ],
+      queryBuilderType: QueryBuilderType.Simple,
+    } ) );
 
-    expect(result.data).toMatchSnapshot();
-  })
+    expect( result.data ).toMatchSnapshot();
+  } )
 
-  test('calibration forecast with assetType groupBy', async () => {
+  test( 'calibration forecast with assetType groupBy', async () =>
+  {
     backendServer.fetch
-      .calledWith(requestMatching({ url: '/niapm/v1/assets/calibration-forecast' }))
-      .mockReturnValue(createFetchResponse(assetTypeGroupCalibrationForecastResponseMock() as CalibrationForecastResponse))
+      .calledWith( requestMatching( { url: '/niapm/v1/assets/calibration-forecast' } ) )
+      .mockReturnValue( createFetchResponse( assetTypeGroupCalibrationForecastResponseMock() as CalibrationForecastResponse ) )
 
-    const result = await datastore.query(buildCalibrationForecastQuery({ type: AssetQueryType.CalibrationForecast, groupBy: [AssetCalibrationPropertyGroupByType.AssetType] }))
+    const result = await datastore.query( buildCalibrationForecastQuery( { type: AssetQueryType.CalibrationForecast, groupBy: [ AssetCalibrationPropertyGroupByType.AssetType ], queryBuilderType: QueryBuilderType.Simple, } ) )
 
-    expect(result.data).toMatchSnapshot();
-  })
+    expect( result.data ).toMatchSnapshot();
+  } )
 
-  test('calibration forecast with month and assetType groupBy', async () => {
+  test( 'calibration forecast with month and assetType groupBy', async () =>
+  {
     backendServer.fetch
-      .calledWith(requestMatching({ url: '/niapm/v1/assets/calibration-forecast' }))
-      .mockReturnValue(createFetchResponse(monthAssetTypeGroupCalibrationForecastResponseMock() as CalibrationForecastResponse))
+      .calledWith( requestMatching( { url: '/niapm/v1/assets/calibration-forecast' } ) )
+      .mockReturnValue( createFetchResponse( monthAssetTypeGroupCalibrationForecastResponseMock() as CalibrationForecastResponse ) )
 
-    const result = await datastore.query(buildCalibrationForecastQuery({
+    const result = await datastore.query( buildCalibrationForecastQuery( {
       type: AssetQueryType.CalibrationForecast,
-      groupBy: [AssetCalibrationTimeBasedGroupByType.Month, AssetCalibrationPropertyGroupByType.AssetType]
-    }));
+      groupBy: [ AssetCalibrationTimeBasedGroupByType.Month, AssetCalibrationPropertyGroupByType.AssetType ],
+      queryBuilderType: QueryBuilderType.Simple,
+    } ) );
 
-    expect(result.data).toMatchSnapshot();
-  })
+    expect( result.data ).toMatchSnapshot();
+  } )
 
-  test('calibration forecast with busType groupBy', async () => {
+  test( 'calibration forecast with busType groupBy', async () =>
+  {
     backendServer.fetch
-      .calledWith(requestMatching({ url: '/niapm/v1/assets/calibration-forecast' }))
-      .mockReturnValue(createFetchResponse(busTypeGroupCalibrationForecastResponseMock() as CalibrationForecastResponse))
+      .calledWith( requestMatching( { url: '/niapm/v1/assets/calibration-forecast' } ) )
+      .mockReturnValue( createFetchResponse( busTypeGroupCalibrationForecastResponseMock() as CalibrationForecastResponse ) )
 
-    const result = await datastore.query(buildCalibrationForecastQuery({ type: AssetQueryType.CalibrationForecast, groupBy: [AssetCalibrationPropertyGroupByType.BusType] }))
+    const result = await datastore.query( buildCalibrationForecastQuery( { type: AssetQueryType.CalibrationForecast, groupBy: [ AssetCalibrationPropertyGroupByType.BusType ], queryBuilderType: QueryBuilderType.Simple, } ) )
 
-    expect(result.data).toMatchSnapshot();
-  })
+    expect( result.data ).toMatchSnapshot();
+  } )
 
-  test('calibration forecast with month and busType groupBy', async () => {
+  test( 'calibration forecast with month and busType groupBy', async () =>
+  {
     backendServer.fetch
-      .calledWith(requestMatching({ url: '/niapm/v1/assets/calibration-forecast' }))
-      .mockReturnValue(createFetchResponse(monthBusTypeGroupCalibrationForecastResponseMock() as CalibrationForecastResponse))
+      .calledWith( requestMatching( { url: '/niapm/v1/assets/calibration-forecast' } ) )
+      .mockReturnValue( createFetchResponse( monthBusTypeGroupCalibrationForecastResponseMock() as CalibrationForecastResponse ) )
 
-    const result = await datastore.query(buildCalibrationForecastQuery({
+    const result = await datastore.query( buildCalibrationForecastQuery( {
       type: AssetQueryType.CalibrationForecast,
-      groupBy: [AssetCalibrationTimeBasedGroupByType.Month, AssetCalibrationPropertyGroupByType.BusType]
-    }));
+      groupBy: [ AssetCalibrationTimeBasedGroupByType.Month, AssetCalibrationPropertyGroupByType.BusType ],
+      queryBuilderType: QueryBuilderType.Simple,
+    } ) );
 
-    expect(result.data).toMatchSnapshot();
-  })
+    expect( result.data ).toMatchSnapshot();
+  } )
 
-  test('calibration forecast with month groupBy returns empty results', async () => {
+  test( 'calibration forecast with month groupBy returns empty results', async () =>
+  {
     backendServer.fetch
-      .calledWith(requestMatching({ url: '/niapm/v1/assets/calibration-forecast' }))
-      .mockReturnValue(createFetchResponse(emptyGroupCalibrationForecastResponseMock() as CalibrationForecastResponse))
+      .calledWith( requestMatching( { url: '/niapm/v1/assets/calibration-forecast' } ) )
+      .mockReturnValue( createFetchResponse( emptyGroupCalibrationForecastResponseMock() as CalibrationForecastResponse ) )
 
-    const result = await datastore.query(buildCalibrationForecastQuery(monthBasedCalibrationForecastQueryMock))
+    const result = await datastore.query( buildCalibrationForecastQuery( monthBasedCalibrationForecastQueryMock ) )
 
-    expect(result.data).toMatchSnapshot()
-  })
+    expect( result.data ).toMatchSnapshot()
+  } )
 
-  test('handles metadata query error', async () => {
+  test( 'handles metadata query error', async () =>
+  {
     backendServer.fetch
-      .calledWith(requestMatching({ url: '/niapm/v1/assets/calibration-forecast' }))
-      .mockReturnValue(createFetchError(418))
+      .calledWith( requestMatching( { url: '/niapm/v1/assets/calibration-forecast' } ) )
+      .mockReturnValue( createFetchError( 418 ) )
 
-    await expect(datastore.query(buildCalibrationForecastQuery(monthBasedCalibrationForecastQueryMock))).rejects.toThrow()
-  })
+    await expect( datastore.query( buildCalibrationForecastQuery( monthBasedCalibrationForecastQueryMock ) ) ).rejects.toThrow()
+  } )
 
-  test('validate DAY grouping', async () => {
-    const request = buildCalibrationForecastQuery(dayBasedCalibrationForecastQueryMock);
+  test( 'validate DAY grouping', async () =>
+  {
+    const request = buildCalibrationForecastQuery( dayBasedCalibrationForecastQueryMock );
     const numberOfDays = 31 * 3 + 1;
-    request.range = { from: dateTime().subtract(numberOfDays, 'day'), to: dateTime(), raw: { from: `now-${numberOfDays}d`, to: 'now' } };
+    request.range = { from: dateTime().subtract( numberOfDays, 'day' ), to: dateTime(), raw: { from: `now-${ numberOfDays }d`, to: 'now' } };
 
-    await expect(datastore.query(request)).rejects.toThrow('Query range exceeds range limit of DAY grouping method: 3 months');
-  })
+    await expect( datastore.query( request ) ).rejects.toThrow( 'Query range exceeds range limit of DAY grouping method: 3 months' );
+  } )
 
-  test('validate WEEK grouping', async () => {
-    const request = buildCalibrationForecastQuery(weekBasedCalibrationForecastQueryMock);
+  test( 'validate WEEK grouping', async () =>
+  {
+    const request = buildCalibrationForecastQuery( weekBasedCalibrationForecastQueryMock );
     const numberOfDays = 366 * 2 + 1;
-    request.range = { from: dateTime().subtract(numberOfDays, 'day'), to: dateTime(), raw: { from: `now-${numberOfDays}d`, to: 'now' } };
+    request.range = { from: dateTime().subtract( numberOfDays, 'day' ), to: dateTime(), raw: { from: `now-${ numberOfDays }d`, to: 'now' } };
 
-    await expect(datastore.query(request)).rejects.toThrow('Query range exceeds range limit of WEEK grouping method: 2 years');
-  })
+    await expect( datastore.query( request ) ).rejects.toThrow( 'Query range exceeds range limit of WEEK grouping method: 2 years' );
+  } )
 
-  test('validate MONTH grouping', async () => {
-    const request = buildCalibrationForecastQuery(monthBasedCalibrationForecastQueryMock);
+  test( 'validate MONTH grouping', async () =>
+  {
+    const request = buildCalibrationForecastQuery( monthBasedCalibrationForecastQueryMock );
     const numberOfDays = 366 * 5 + 1;
-    request.range = { from: dateTime().subtract(numberOfDays, 'day'), to: dateTime(), raw: { from: `now-${numberOfDays}d`, to: 'now' } };
+    request.range = { from: dateTime().subtract( numberOfDays, 'day' ), to: dateTime(), raw: { from: `now-${ numberOfDays }d`, to: 'now' } };
 
-    await expect(datastore.query(request)).rejects.toThrow('Query range exceeds range limit of MONTH grouping method: 5 years');
-  })
-})
+    await expect( datastore.query( request ) ).rejects.toThrow( 'Query range exceeds range limit of MONTH grouping method: 5 years' );
+  } )
+} )
 
-describe('Asset calibration location queries', () => {
+describe( 'Asset calibration location queries', () =>
+{
   let processCalibrationForecastQuerySpy: jest.SpyInstance;
 
-  beforeEach(() => {
-    processCalibrationForecastQuerySpy = jest.spyOn(datastore, 'processCalibrationForecastQuery').mockImplementation();
-  });
+  beforeEach( () =>
+  {
+    processCalibrationForecastQuerySpy = jest.spyOn( datastore, 'processCalibrationForecastQuery' ).mockImplementation();
+  } );
 
-  test('should transform LOCATION field with single value', async () => {
-    const query = buildCalibrationForecastQuery({
+  test( 'should transform LOCATION field with single value', async () =>
+  {
+    const query = buildCalibrationForecastQuery( {
       refId: '',
       type: AssetQueryType.CalibrationForecast,
-      groupBy: [AssetCalibrationTimeBasedGroupByType.Month],
-      filter: `${AssetCalibrationFieldNames.LOCATION} = "Location1"`,
-    });
+      groupBy: [ AssetCalibrationTimeBasedGroupByType.Month ],
+      filter: `${ AssetCalibrationFieldNames.LOCATION } = "Location1"`,
+      queryBuilderType: QueryBuilderType.Simple,
+    } );
 
-    await datastore.query(query);
+    await datastore.query( query );
 
-    expect(processCalibrationForecastQuerySpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        groupBy: [AssetCalibrationTimeBasedGroupByType.Month],
+    expect( processCalibrationForecastQuerySpy ).toHaveBeenCalledWith(
+      expect.objectContaining( {
+        groupBy: [ AssetCalibrationTimeBasedGroupByType.Month ],
         filter: "Locations.Any(l => l.MinionId = \"Location1\" || l.PhysicalLocation = \"Location1\")"
-      }),
+      } ),
       expect.anything()
     );
-  });
+  } );
 
-  test('should transform LOCATION field with single value and cache hit', async () => {
-    datastore.systemAliasCache.set('Location1', { id: 'Location1', alias: 'Location1-alias', state: 'CONNECTED', workspace: '1' });
+  test( 'should transform LOCATION field with single value and cache hit', async () =>
+  {
+    datastore.systemAliasCache.set( 'Location1', { id: 'Location1', alias: 'Location1-alias', state: 'CONNECTED', workspace: '1' } );
 
-    const query = buildCalibrationForecastQuery({
+    const query = buildCalibrationForecastQuery( {
       refId: '',
       type: AssetQueryType.CalibrationForecast,
-      groupBy: [AssetCalibrationTimeBasedGroupByType.Month],
-      filter: `${AssetCalibrationFieldNames.LOCATION} = "Location1"`,
-    });
+      groupBy: [ AssetCalibrationTimeBasedGroupByType.Month ],
+      filter: `${ AssetCalibrationFieldNames.LOCATION } = "Location1"`,
+      queryBuilderType: QueryBuilderType.Simple,
+    } );
 
-    await datastore.query(query);
+    await datastore.query( query );
 
-    expect(processCalibrationForecastQuerySpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        groupBy: [AssetCalibrationTimeBasedGroupByType.Month],
+    expect( processCalibrationForecastQuerySpy ).toHaveBeenCalledWith(
+      expect.objectContaining( {
+        groupBy: [ AssetCalibrationTimeBasedGroupByType.Month ],
         filter: "Location.MinionId = \"Location1\""
-      }),
+      } ),
       expect.anything()
     );
-  });
+  } );
 
-  test('should transform LOCATION field with multiple values and cache hit', async () => {
-    datastore.systemAliasCache.set('Location1', { id: 'Location1', alias: 'Location1-alias', state: 'CONNECTED', workspace: '1' });
-    datastore.systemAliasCache.set('Location2', { id: 'Location2', alias: 'Location2-alias', state: 'CONNECTED', workspace: '2' });
+  test( 'should transform LOCATION field with multiple values and cache hit', async () =>
+  {
+    datastore.systemAliasCache.set( 'Location1', { id: 'Location1', alias: 'Location1-alias', state: 'CONNECTED', workspace: '1' } );
+    datastore.systemAliasCache.set( 'Location2', { id: 'Location2', alias: 'Location2-alias', state: 'CONNECTED', workspace: '2' } );
 
-    const query = buildCalibrationForecastQuery({
+    const query = buildCalibrationForecastQuery( {
       refId: '',
       type: AssetQueryType.CalibrationForecast,
-      groupBy: [AssetCalibrationTimeBasedGroupByType.Month],
-      filter: `${AssetCalibrationFieldNames.LOCATION} = "{Location1,Location2}"`,
-    });
+      groupBy: [ AssetCalibrationTimeBasedGroupByType.Month ],
+      filter: `${ AssetCalibrationFieldNames.LOCATION } = "{Location1,Location2}"`,
+      queryBuilderType: QueryBuilderType.Simple,
+    } );
 
-    await datastore.query(query);
+    await datastore.query( query );
 
-    expect(processCalibrationForecastQuerySpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        groupBy: [AssetCalibrationTimeBasedGroupByType.Month],
+    expect( processCalibrationForecastQuerySpy ).toHaveBeenCalledWith(
+      expect.objectContaining( {
+        groupBy: [ AssetCalibrationTimeBasedGroupByType.Month ],
         filter: "(Location.MinionId = \"Location1\" || Location.MinionId = \"Location2\")"
-      }),
+      } ),
       expect.anything()
     );
-  });
-});
+  } );
+} );
 
-describe('Time based data links', () => {
-  test('creates data links for Day grouping', async () => {
-    const query = buildCalibrationForecastQuery(dayBasedCalibrationForecastQueryMock);
-    query.range = { from: dateTime("2022-01-01T00:00:00.0000000Z"), to: dateTime("2022-03-01T00:00:00.0000000Z"), raw: { from: 'now', to: 'now+3M' } };
+describe( 'Time based data links', () =>
+{
+  test( 'creates data links for Day grouping', async () =>
+  {
+    const query = buildCalibrationForecastQuery( dayBasedCalibrationForecastQueryMock );
+    query.range = { from: dateTime( "2022-01-01T00:00:00.0000000Z" ), to: dateTime( "2022-03-01T00:00:00.0000000Z" ), raw: { from: 'now', to: 'now+3M' } };
     query.timezone = 'UTC';
 
     backendServer.fetch
-      .calledWith(requestMatching({ url: '/niapm/v1/assets/calibration-forecast' }))
-      .mockReturnValue(createFetchResponse(dayGroupCalibrationForecastResponseMock() as CalibrationForecastResponse));
+      .calledWith( requestMatching( { url: '/niapm/v1/assets/calibration-forecast' } ) )
+      .mockReturnValue( createFetchResponse( dayGroupCalibrationForecastResponseMock() as CalibrationForecastResponse ) );
 
-    const result = await datastore.query(query);
-    const [_day, assets] = result.data[0].fields;
-    const [dataLink] = assets.config.links;
+    const result = await datastore.query( query );
+    const [ _day, assets ] = result.data[ 0 ].fields;
+    const [ dataLink ] = assets.config.links;
 
-    const from = new Date('2022-01-01T00:00:00.0000000Z');
+    const from = new Date( '2022-01-01T00:00:00.0000000Z' );
 
-    expect(dataLink.title).toBe(`View ${AssetCalibrationForecastKey.Day}`);
-    expect(dataLink.targetBlank).toBe(false);
+    expect( dataLink.title ).toBe( `View ${ AssetCalibrationForecastKey.Day }` );
+    expect( dataLink.targetBlank ).toBe( false );
 
-    const builtUrl = dataLink.onBuildUrl({
-      replaceVariables: (value: string) => value.replace('${__data.fields.Day}', from.toISOString().split('T')[0])
-    });
+    const builtUrl = dataLink.onBuildUrl( {
+      replaceVariables: ( value: string ) => value.replace( '${__data.fields.Day}', from.toISOString().split( 'T' )[ 0 ] )
+    } );
 
-    expect(builtUrl).toMatchSnapshot();
-  });
+    expect( builtUrl ).toMatchSnapshot();
+  } );
 
-  test('creates data links for Week grouping', async () => {
+  test( 'creates data links for Week grouping', async () =>
+  {
     backendServer.fetch
-      .calledWith(requestMatching({ url: '/niapm/v1/assets/calibration-forecast' }))
-      .mockReturnValue(createFetchResponse(weekGroupCalibrationForecastDataLinkResponseMock() as CalibrationForecastResponse));
+      .calledWith( requestMatching( { url: '/niapm/v1/assets/calibration-forecast' } ) )
+      .mockReturnValue( createFetchResponse( weekGroupCalibrationForecastDataLinkResponseMock() as CalibrationForecastResponse ) );
 
-    const query = buildCalibrationForecastQuery(weekBasedCalibrationForecastQueryMock);
-    query.range = { from: dateTime("2022-01-01T00:00:00.0000000Z"), to: dateTime("2022-03-01T00:00:00.0000000Z"), raw: { from: 'now', to: 'now+3M' } };
+    const query = buildCalibrationForecastQuery( weekBasedCalibrationForecastQueryMock );
+    query.range = { from: dateTime( "2022-01-01T00:00:00.0000000Z" ), to: dateTime( "2022-03-01T00:00:00.0000000Z" ), raw: { from: 'now', to: 'now+3M' } };
     query.timezone = 'UTC';
 
-    const result = await datastore.query(query);
-    const [_week, assets] = result.data[0].fields;
-    const [dataLink] = assets.config.links;
+    const result = await datastore.query( query );
+    const [ _week, assets ] = result.data[ 0 ].fields;
+    const [ dataLink ] = assets.config.links;
 
-    const weekStartDate = new Date('2022-01-01T00:00:00.0000000Z');
-    const weekEndDate = new Date('2022-01-07T23:59:59.999Z');
+    const weekStartDate = new Date( '2022-01-01T00:00:00.0000000Z' );
+    const weekEndDate = new Date( '2022-01-07T23:59:59.999Z' );
 
-    expect(dataLink.title).toBe(`View ${AssetCalibrationForecastKey.Week}`);
-    expect(dataLink.targetBlank).toBe(false);
+    expect( dataLink.title ).toBe( `View ${ AssetCalibrationForecastKey.Week }` );
+    expect( dataLink.targetBlank ).toBe( false );
 
-    const builtUrl = dataLink.onBuildUrl({
-      replaceVariables: (value: string) => value.replace('${__data.fields.Week}', `${weekStartDate.toISOString().split('T')[0]} : ${weekEndDate.toISOString().split('T')[0]}`)
-    });
+    const builtUrl = dataLink.onBuildUrl( {
+      replaceVariables: ( value: string ) => value.replace( '${__data.fields.Week}', `${ weekStartDate.toISOString().split( 'T' )[ 0 ] } : ${ weekEndDate.toISOString().split( 'T' )[ 0 ] }` )
+    } );
 
-    expect(builtUrl).toMatchSnapshot();
-  });
+    expect( builtUrl ).toMatchSnapshot();
+  } );
 
-  test('creates data links for Month grouping', async () => {
-    const query = buildCalibrationForecastQuery(monthBasedCalibrationForecastQueryMock)
-    query.range = { from: dateTime("2022-01-01T00:00:00.0000000Z"), to: dateTime("2022-03-01T00:00:00.0000000Z"), raw: { from: 'now', to: 'now+3M' } };
+  test( 'creates data links for Month grouping', async () =>
+  {
+    const query = buildCalibrationForecastQuery( monthBasedCalibrationForecastQueryMock )
+    query.range = { from: dateTime( "2022-01-01T00:00:00.0000000Z" ), to: dateTime( "2022-03-01T00:00:00.0000000Z" ), raw: { from: 'now', to: 'now+3M' } };
     query.timezone = 'UTC';
     backendServer.fetch
-      .calledWith(requestMatching({ url: '/niapm/v1/assets/calibration-forecast' }))
-      .mockReturnValue(createFetchResponse(monthGroupCalibrationForecastResponseMock() as CalibrationForecastResponse));
+      .calledWith( requestMatching( { url: '/niapm/v1/assets/calibration-forecast' } ) )
+      .mockReturnValue( createFetchResponse( monthGroupCalibrationForecastResponseMock() as CalibrationForecastResponse ) );
 
-    const result = await datastore.query(query);
-    const [_month, assets] = result.data[0].fields;
-    const [dataLink] = assets.config.links;
+    const result = await datastore.query( query );
+    const [ _month, assets ] = result.data[ 0 ].fields;
+    const [ dataLink ] = assets.config.links;
 
-    expect(dataLink.title).toBe(`View ${AssetCalibrationForecastKey.Month}`);
-    expect(dataLink.targetBlank).toBe(false);
+    expect( dataLink.title ).toBe( `View ${ AssetCalibrationForecastKey.Month }` );
+    expect( dataLink.targetBlank ).toBe( false );
 
-    const builtUrl = dataLink.onBuildUrl({
-      replaceVariables: (value: string) => value.replace('${__data.fields.Month}', "January 2022")
-    });
+    const builtUrl = dataLink.onBuildUrl( {
+      replaceVariables: ( value: string ) => value.replace( '${__data.fields.Month}', "January 2022" )
+    } );
 
-    expect(builtUrl).toMatchSnapshot();
-  });
-});
+    expect( builtUrl ).toMatchSnapshot();
+  } );
+} );
diff --git a/src/datasources/asset/data-sources/calibration-forecast/CalibrationForecastDataSource.ts b/src/datasources/asset/data-sources/calibration-forecast/CalibrationForecastDataSource.ts
index ee37c30e..eb13889e 100644
--- a/src/datasources/asset/data-sources/calibration-forecast/CalibrationForecastDataSource.ts
+++ b/src/datasources/asset/data-sources/calibration-forecast/CalibrationForecastDataSource.ts
@@ -5,22 +5,25 @@ import { AssetDataSourceBase } from '../AssetDataSourceBase';
 import { AssetCalibrationForecastKey, AssetCalibrationTimeBasedGroupByType, CalibrationForecastQuery, CalibrationForecastResponse, ColumnDescriptorType, FieldDTOWithDescriptor } from '../../types/CalibrationForecastQuery.types';
 import { transformComputedFieldsQuery } from '../../../../core/query-builder.utils';
 import { AssetModel, AssetsResponse } from '../../../asset-common/types';
+import { QueryBuilderType } from 'datasources/asset/constants/constants';
 
-export class CalibrationForecastDataSource extends AssetDataSourceBase {
+export class CalibrationForecastDataSource extends AssetDataSourceBase
+{
     private dependenciesLoadedPromise: Promise<void>;
 
-    private readonly forecastDateFormatterMap = new Map<AssetCalibrationForecastKey, (date: string) => string>([
-        [AssetCalibrationForecastKey.Day, this.formatDateForDay],
-        [AssetCalibrationForecastKey.Week, this.formatDateForWeek],
-        [AssetCalibrationForecastKey.Month, this.formatDateForMonth]
-    ]);
+    private readonly forecastDateFormatterMap = new Map<AssetCalibrationForecastKey, ( date: string ) => string>( [
+        [ AssetCalibrationForecastKey.Day, this.formatDateForDay ],
+        [ AssetCalibrationForecastKey.Week, this.formatDateForWeek ],
+        [ AssetCalibrationForecastKey.Month, this.formatDateForMonth ]
+    ] );
 
-    constructor(
+    constructor (
         readonly instanceSettings: DataSourceInstanceSettings<AssetDataSourceOptions>,
         readonly backendSrv: BackendSrv = getBackendSrv(),
         readonly templateSrv: TemplateSrv = getTemplateSrv()
-    ) {
-        super(instanceSettings, backendSrv, templateSrv);
+    )
+    {
+        super( instanceSettings, backendSrv, templateSrv );
         this.dependenciesLoadedPromise = this.loadDependencies();
     }
 
@@ -29,42 +32,48 @@ export class CalibrationForecastDataSource extends AssetDataSourceBase {
     defaultQuery = {
         type: AssetQueryType.CalibrationForecast,
         groupBy: [],
-        filter: ''
+        filter: '',
+        queryBuilderType: QueryBuilderType.Simple,
     };
 
-    public readonly busTypeCache = new Map<BusType, string>([
-        ...BusTypeOptions.map(busType => [busType.value, busType.label]) as Array<[BusType, string]>
-    ]);
-    public readonly assetTypeCache = new Map<AssetType, string>([
-        ...AssetTypeOptions.map(assetType => [assetType.value, assetType.label]) as Array<[AssetType, string]>
-    ]);
+    public readonly busTypeCache = new Map<BusType, string>( [
+        ...BusTypeOptions.map( busType => [ busType.value, busType.label ] ) as Array<[ BusType, string ]>
+    ] );
+    public readonly assetTypeCache = new Map<AssetType, string>( [
+        ...AssetTypeOptions.map( assetType => [ assetType.value, assetType.label ] ) as Array<[ AssetType, string ]>
+    ] );
 
-    async runQuery(query: AssetQuery, options: DataQueryRequest): Promise<DataFrameDTO> {
+    async runQuery ( query: AssetQuery, options: DataQueryRequest ): Promise<DataFrameDTO>
+    {
         const calibrationForecastQuery = query as CalibrationForecastQuery;
         await this.dependenciesLoadedPromise;
-        this.validateQueryRange(calibrationForecastQuery, options);
+        this.validateQueryRange( calibrationForecastQuery, options );
 
-        if (calibrationForecastQuery.filter) {
+        if ( calibrationForecastQuery.filter )
+        {
             calibrationForecastQuery.filter = transformComputedFieldsQuery(
-                this.templateSrv.replace(calibrationForecastQuery.filter, options.scopedVars),
+                this.templateSrv.replace( calibrationForecastQuery.filter, options.scopedVars ),
                 this.assetComputedDataFields,
                 this.queryTransformationOptions
             );
         }
 
-        return await this.processCalibrationForecastQuery(calibrationForecastQuery, options);
+        return await this.processCalibrationForecastQuery( calibrationForecastQuery, options );
     }
 
-    shouldRunQuery(calibrationQuery: CalibrationForecastQuery): boolean {
+    shouldRunQuery ( calibrationQuery: CalibrationForecastQuery ): boolean
+    {
         return calibrationQuery.groupBy.length > 0;
     }
 
-    async testDatasource(): Promise<TestDataSourceResponse> {
-        await this.get(this.baseUrl + '/assets?take=1');
+    async testDatasource (): Promise<TestDataSourceResponse>
+    {
+        await this.get( this.baseUrl + '/assets?take=1' );
         return { status: 'success', message: 'Data source connected and authentication successful!' };
     }
 
-    async processCalibrationForecastQuery(query: CalibrationForecastQuery, options: DataQueryRequest) {
+    async processCalibrationForecastQuery ( query: CalibrationForecastQuery, options: DataQueryRequest )
+    {
         const result: DataFrameDTO = { refId: query.refId, fields: [] };
         const from = options.range!.from.utc().toISOString();
         const to = options.range!.to.utc().toISOString();
@@ -78,78 +87,98 @@ export class CalibrationForecastDataSource extends AssetDataSourceBase {
 
         result.fields = calibrationForecastResponse.calibrationForecast.columns || [];
 
-        const timeGrouping = this.getTimeGroup(query);
-        if (timeGrouping) {
-            this.processResultsGroupedByTime(result, timeGrouping, options)
-        } else {
-            this.processResultsGroupedByProperties(result)
+        const timeGrouping = this.getTimeGroup( query );
+        if ( timeGrouping )
+        {
+            this.processResultsGroupedByTime( result, timeGrouping, options )
+        } else
+        {
+            this.processResultsGroupedByProperties( result )
         }
 
         return result;
     }
 
-    getTimeGroup(query: CalibrationForecastQuery) {
-        if (query.groupBy.includes(AssetCalibrationTimeBasedGroupByType.Day)) {
+    getTimeGroup ( query: CalibrationForecastQuery )
+    {
+        if ( query.groupBy.includes( AssetCalibrationTimeBasedGroupByType.Day ) )
+        {
             return AssetCalibrationForecastKey.Day;
         }
-        if (query.groupBy.includes(AssetCalibrationTimeBasedGroupByType.Week)) {
+        if ( query.groupBy.includes( AssetCalibrationTimeBasedGroupByType.Week ) )
+        {
             return AssetCalibrationForecastKey.Week;
         }
-        if (query.groupBy.includes(AssetCalibrationTimeBasedGroupByType.Month)) {
+        if ( query.groupBy.includes( AssetCalibrationTimeBasedGroupByType.Month ) )
+        {
             return AssetCalibrationForecastKey.Month;
         }
         return null;
     }
 
-    processResultsGroupedByTime(result: DataFrameDTO, timeGrouping: AssetCalibrationForecastKey, options: DataQueryRequest) {
-        const originalValuesMap = this.constructDataLinkValuesMap(result, options);
-        result.fields.forEach(field => {
-            field.name = this.createColumnNameFromDescriptor(field as FieldDTOWithDescriptor);
-            const formatter = this.forecastDateFormatterMap.get(field.name as AssetCalibrationForecastKey);
+    processResultsGroupedByTime ( result: DataFrameDTO, timeGrouping: AssetCalibrationForecastKey, options: DataQueryRequest )
+    {
+        const originalValuesMap = this.constructDataLinkValuesMap( result, options );
+        result.fields.forEach( field =>
+        {
+            field.name = this.createColumnNameFromDescriptor( field as FieldDTOWithDescriptor );
+            const formatter = this.forecastDateFormatterMap.get( field.name as AssetCalibrationForecastKey );
 
-            if (formatter) {
-                field.values = field.values!.map(formatter);
+            if ( formatter )
+            {
+                field.values = field.values!.map( formatter );
             }
 
-            if (!formatter) {
-                field.config = { links: this.createDataLinks(timeGrouping, originalValuesMap) };
+            if ( !formatter )
+            {
+                field.config = { links: this.createDataLinks( timeGrouping, originalValuesMap ) };
             }
-        });
+        } );
     }
 
-    private constructDataLinkValuesMap(result: DataFrameDTO, options: DataQueryRequest): Map<string, { from: number, to: number }> {
+    private constructDataLinkValuesMap ( result: DataFrameDTO, options: DataQueryRequest ): Map<string, { from: number, to: number }>
+    {
         const originalValuesMap = new Map<string, { from: number, to: number }>();
-        if (result.fields.length > 0) {
-            const field = result.fields[0];
+        if ( result.fields.length > 0 )
+        {
+            const field = result.fields[ 0 ];
             const originalValues = field.values as string[] ?? [];
-            const formatter = this.forecastDateFormatterMap.get(field.name as AssetCalibrationForecastKey);
-            if (formatter) {
+            const formatter = this.forecastDateFormatterMap.get( field.name as AssetCalibrationForecastKey );
+            if ( formatter )
+            {
                 let value = { from: 0, to: 0 }
-                const formattedValues: string[] = field.values!.map(formatter);
-                if (originalValues.length === 0) {
+                const formattedValues: string[] = field.values!.map( formatter );
+                if ( originalValues.length === 0 )
+                {
                     return originalValuesMap;
                 }
-                else if (originalValues.length === 1) {
+                else if ( originalValues.length === 1 )
+                {
                     value.from = options.range.from.utc().toDate().valueOf();
                     value.to = options.range.to.utc().toDate().valueOf();
 
-                    originalValuesMap.set(formattedValues![0], value);
-                } else {
-                    for (let i = 0; i < originalValues!.length; i++) {
+                    originalValuesMap.set( formattedValues![ 0 ], value );
+                } else
+                {
+                    for ( let i = 0; i < originalValues!.length; i++ )
+                    {
                         value = { from: 0, to: 0 }
-                        if (i === 0) {
+                        if ( i === 0 )
+                        {
                             value.from = options.range.from.utc().toDate().valueOf();
-                            value.to = new Date(originalValues[i + 1]).valueOf();
+                            value.to = new Date( originalValues[ i + 1 ] ).valueOf();
                         }
-                        else if (i === originalValues!.length - 1) {
-                            value.from = new Date(originalValues[i]).valueOf();
+                        else if ( i === originalValues!.length - 1 )
+                        {
+                            value.from = new Date( originalValues[ i ] ).valueOf();
                             value.to = options.range.to.utc().toDate().valueOf();
                         }
-                        else {
-                            value.from = new Date(originalValues[i]).valueOf();
-                            value.to = new Date(originalValues[i + 1]).valueOf();
+                        else
+                        {
+                            value.from = new Date( originalValues[ i ] ).valueOf();
+                            value.to = new Date( originalValues[ i + 1 ] ).valueOf();
                         }
-                        originalValuesMap.set(formattedValues![i], value);
+                        originalValuesMap.set( formattedValues![ i ], value );
                     }
                 }
             }
@@ -158,106 +187,126 @@ export class CalibrationForecastDataSource extends AssetDataSourceBase {
         return originalValuesMap;
     }
 
-    private constructDataLinkBaseUrl() {
+    private constructDataLinkBaseUrl ()
+    {
         const pathname = locationService.getLocation().pathname;
         return pathname + '?orgId=${__org.id}&${__all_variables}';
     }
 
-    private createDataLinks(timeGrouping: AssetCalibrationForecastKey, originalValuesMap: Map<string, { from: any, to: any }>): DataLink[] {
+    private createDataLinks ( timeGrouping: AssetCalibrationForecastKey, originalValuesMap: Map<string, { from: any, to: any }> ): DataLink[]
+    {
         const url = this.constructDataLinkBaseUrl();
         return [
             {
-                title: `View ${timeGrouping}`, targetBlank: false, url: `${url}`,
-                onBuildUrl: function (options) {
-                    if (!options.replaceVariables) {
+                title: `View ${ timeGrouping }`, targetBlank: false, url: `${ url }`,
+                onBuildUrl: function ( options )
+                {
+                    if ( !options.replaceVariables )
+                    {
                         return url;
                     }
-                    const value = options.replaceVariables(`\${__data.fields.${timeGrouping}}`);
-                    if (!value) {
+                    const value = options.replaceVariables( `\${__data.fields.${ timeGrouping }}` );
+                    if ( !value )
+                    {
                         return url;
                     }
-                    const valueAsDate = originalValuesMap.get(value)!;
-                    return `${url}&from=${valueAsDate?.from}&to=${valueAsDate?.to}`;
+                    const valueAsDate = originalValuesMap.get( value )!;
+                    return `${ url }&from=${ valueAsDate?.from }&to=${ valueAsDate?.to }`;
                 }
             }
         ];
     }
 
-    processResultsGroupedByProperties(result: DataFrameDTO) {
+    processResultsGroupedByProperties ( result: DataFrameDTO )
+    {
         const formattedFields = [] as FieldDTO[];
-        formattedFields.push({ name: "Group", values: [] } as FieldDTO);
-        formattedFields.push({ name: "Assets", values: [] } as FieldDTO);
-
-        for (let columnIndex = 0; columnIndex < result.fields.length; columnIndex++) {
-            const columnName = this.createColumnNameFromDescriptor(result.fields[columnIndex] as FieldDTOWithDescriptor);
-            const columnValue = result.fields[columnIndex].values?.at(0);
-            formattedFields[0].values!.push(columnName);
-            formattedFields[1].values!.push(columnValue);
+        formattedFields.push( { name: "Group", values: [] } as FieldDTO );
+        formattedFields.push( { name: "Assets", values: [] } as FieldDTO );
+
+        for ( let columnIndex = 0; columnIndex < result.fields.length; columnIndex++ )
+        {
+            const columnName = this.createColumnNameFromDescriptor( result.fields[ columnIndex ] as FieldDTOWithDescriptor );
+            const columnValue = result.fields[ columnIndex ].values?.at( 0 );
+            formattedFields[ 0 ].values!.push( columnName );
+            formattedFields[ 1 ].values!.push( columnValue );
         }
 
         result.fields = formattedFields;
     }
 
-    createColumnNameFromDescriptor(field: FieldDTOWithDescriptor): string {
-        return field.columnDescriptors.map(descriptor => {
-            switch (descriptor.type) {
+    createColumnNameFromDescriptor ( field: FieldDTOWithDescriptor ): string
+    {
+        return field.columnDescriptors.map( descriptor =>
+        {
+            switch ( descriptor.type )
+            {
                 case ColumnDescriptorType.MinionId:
-                    return this.systemAliasCache.get(descriptor.value)?.alias || descriptor.value;
+                    return this.systemAliasCache.get( descriptor.value )?.alias || descriptor.value;
                 case ColumnDescriptorType.WorkspaceId:
-                    return this.workspacesCache.get(descriptor.value)?.name || descriptor.value
+                    return this.workspacesCache.get( descriptor.value )?.name || descriptor.value
                 case ColumnDescriptorType.AssetType:
-                    return this.assetTypeCache.get(descriptor.value as AssetType) || descriptor.value;
+                    return this.assetTypeCache.get( descriptor.value as AssetType ) || descriptor.value;
                 case ColumnDescriptorType.BusType:
-                    return this.busTypeCache.get(descriptor.value as BusType) || descriptor.value;
+                    return this.busTypeCache.get( descriptor.value as BusType ) || descriptor.value;
                 default:
                     return descriptor.value;
             }
-        }).join(' - ');
+        } ).join( ' - ' );
     }
 
-    formatDateForDay(date: string): string {
-        return new Date(date).toISOString().split('T')[0];
+    formatDateForDay ( date: string ): string
+    {
+        return new Date( date ).toISOString().split( 'T' )[ 0 ];
     }
 
-    formatDateForWeek(date: string): string {
-        const startDate = new Date(date);
-        const endDate = new Date(startDate);
-        endDate.setDate(startDate.getDate() + 6);
-        return `${startDate.toISOString().split('T')[0]} : ${endDate.toISOString().split('T')[0]}`;
+    formatDateForWeek ( date: string ): string
+    {
+        const startDate = new Date( date );
+        const endDate = new Date( startDate );
+        endDate.setDate( startDate.getDate() + 6 );
+        return `${ startDate.toISOString().split( 'T' )[ 0 ] } : ${ endDate.toISOString().split( 'T' )[ 0 ] }`;
     }
 
-    formatDateForMonth(date: string): string {
-        return new Date(date).toLocaleDateString('en-US', { year: 'numeric', month: 'long', timeZone: 'UTC' });
+    formatDateForMonth ( date: string ): string
+    {
+        return new Date( date ).toLocaleDateString( 'en-US', { year: 'numeric', month: 'long', timeZone: 'UTC' } );
     }
 
-    async queryAssets(filter = '', take = -1): Promise<AssetModel[]> {
+    async queryAssets ( filter = '', take = -1 ): Promise<AssetModel[]>
+    {
         let data = { filter, take };
-        try {
-            let response = await this.post<AssetsResponse>(this.baseUrl + '/query-assets', data);
+        try
+        {
+            let response = await this.post<AssetsResponse>( this.baseUrl + '/query-assets', data );
             return response.assets;
-        } catch (error) {
-            throw new Error(`An error occurred while querying assets: ${error}`);
+        } catch ( error )
+        {
+            throw new Error( `An error occurred while querying assets: ${ error }` );
         }
     }
 
-    async queryCalibrationForecast(groupBy: string[], startTime: string, endTime: string, filter = '', includeOnlyDataInTimeRange = true): Promise<CalibrationForecastResponse> {
+    async queryCalibrationForecast ( groupBy: string[], startTime: string, endTime: string, filter = '', includeOnlyDataInTimeRange = true ): Promise<CalibrationForecastResponse>
+    {
         let data = { groupBy, startTime, endTime, filter, includeOnlyDataInTimeRange };
-        try {
-            let response = await this.post<CalibrationForecastResponse>(this.baseUrl + '/assets/calibration-forecast', data);
+        try
+        {
+            let response = await this.post<CalibrationForecastResponse>( this.baseUrl + '/assets/calibration-forecast', data );
             return response;
-        } catch (error) {
-            throw new Error(`An error occurred while querying assets calibration forecast: ${error}`);
+        } catch ( error )
+        {
+            throw new Error( `An error occurred while querying assets calibration forecast: ${ error }` );
         }
     }
 
-    private validateQueryRange(query: CalibrationForecastQuery, options: DataQueryRequest): void {
+    private validateQueryRange ( query: CalibrationForecastQuery, options: DataQueryRequest ): void
+    {
         const MILLISECONDS_IN_A_DAY = 1000 * 60 * 60 * 24;
         const DAYS_IN_A_MONTH = 31;
         const DAYS_IN_A_YEAR = 366;
 
         const from = options.range!.from;
         const to = options.range!.to;
-        const numberOfDays = Math.abs(to.valueOf() - from.valueOf()) / MILLISECONDS_IN_A_DAY;
+        const numberOfDays = Math.abs( to.valueOf() - from.valueOf() ) / MILLISECONDS_IN_A_DAY;
 
         const rangeLimits = [
             { type: AssetCalibrationTimeBasedGroupByType.Day, limit: DAYS_IN_A_MONTH * 3, groupingMethod: '3 months' },
@@ -265,10 +314,12 @@ export class CalibrationForecastDataSource extends AssetDataSourceBase {
             { type: AssetCalibrationTimeBasedGroupByType.Month, limit: DAYS_IN_A_YEAR * 5, groupingMethod: '5 years' }
         ];
 
-        rangeLimits.forEach(({ type, limit, groupingMethod }) => {
-            if (query.groupBy.includes(type.valueOf()) && numberOfDays > limit) {
-                throw new Error(`Query range exceeds range limit of ${type} grouping method: ${groupingMethod}`);
+        rangeLimits.forEach( ( { type, limit, groupingMethod } ) =>
+        {
+            if ( query.groupBy.includes( type.valueOf() ) && numberOfDays > limit )
+            {
+                throw new Error( `Query range exceeds range limit of ${ type } grouping method: ${ groupingMethod }` );
             }
-        });
+        } );
     }
 }
diff --git a/src/datasources/asset/data-sources/list-assets/ListAssetsDataSource.test.ts b/src/datasources/asset/data-sources/list-assets/ListAssetsDataSource.test.ts
index 750914cf..2afcfe99 100644
--- a/src/datasources/asset/data-sources/list-assets/ListAssetsDataSource.test.ts
+++ b/src/datasources/asset/data-sources/list-assets/ListAssetsDataSource.test.ts
@@ -6,6 +6,7 @@ import { AssetQueryType } from "../../types/types";
 import { ListAssetsDataSource } from "./ListAssetsDataSource";
 import { ListAssetsQuery } from "../../types/ListAssets.types";
 import { ListAssetsFieldNames } from "../../constants/ListAssets.constants";
+import { QueryBuilderType } from "datasources/asset/constants/constants";
 
 let datastore: ListAssetsDataSource;
 
@@ -28,6 +29,7 @@ describe('List assets location queries', () => {
         const query = buildListAssetsQuery({
             refId: '',
             type: AssetQueryType.ListAssets,
+            queryBuilderType: QueryBuilderType.Simple,
             filter: `${ListAssetsFieldNames.LOCATION} = "Location1"`,
         });
 
@@ -46,6 +48,7 @@ describe('List assets location queries', () => {
         const query = buildListAssetsQuery({
             refId: '',
             type: AssetQueryType.ListAssets,
+            queryBuilderType: QueryBuilderType.Simple,
             filter: `${ListAssetsFieldNames.LOCATION} = "Location1"`,
         });
 
@@ -65,6 +68,7 @@ describe('List assets location queries', () => {
         const query = buildListAssetsQuery({
             refId: '',
             type: AssetQueryType.ListAssets,
+            queryBuilderType: QueryBuilderType.Simple,
             filter: `${ListAssetsFieldNames.LOCATION} = "{Location1,Location2}"`,
         });
 
diff --git a/src/datasources/asset/data-sources/list-assets/ListAssetsDataSource.ts b/src/datasources/asset/data-sources/list-assets/ListAssetsDataSource.ts
index 39f74fa4..d5aace22 100644
--- a/src/datasources/asset/data-sources/list-assets/ListAssetsDataSource.ts
+++ b/src/datasources/asset/data-sources/list-assets/ListAssetsDataSource.ts
@@ -6,6 +6,7 @@ import { ListAssetsQuery } from '../../types/ListAssets.types';
 import { AssetModel, AssetsResponse } from '../../../asset-common/types';
 import { getWorkspaceName } from '../../../../core/utils';
 import { transformComputedFieldsQuery } from '../../../../core/query-builder.utils';
+import { QueryBuilderType } from 'datasources/asset/constants/constants';
 
 export class ListAssetsDataSource extends AssetDataSourceBase {
   private dependenciesLoadedPromise: Promise<void>;
@@ -23,13 +24,14 @@ export class ListAssetsDataSource extends AssetDataSourceBase {
 
   defaultQuery = {
     type: AssetQueryType.ListAssets,
+    queryBuilderType: QueryBuilderType.Simple,
     filter: ''
   };
 
   async runQuery(query: AssetQuery, options: DataQueryRequest): Promise<DataFrameDTO> {
     const listAssetsQuery = query as ListAssetsQuery;
     await this.dependenciesLoadedPromise;
-  
+
     if (listAssetsQuery.filter) {
       listAssetsQuery.filter = transformComputedFieldsQuery(
         this.templateSrv.replace(listAssetsQuery.filter, options.scopedVars),
diff --git a/src/datasources/asset/defaults.ts b/src/datasources/asset/defaults.ts
index 191640d1..98147b55 100644
--- a/src/datasources/asset/defaults.ts
+++ b/src/datasources/asset/defaults.ts
@@ -1,3 +1,4 @@
+import { QueryBuilderType } from "./constants/constants"
 
 export const defaultAssetSummaryQuery = {
 }
@@ -8,5 +9,6 @@ export const defaultCalibrationForecastQuery = {
 }
 
 export const defaultListAssetsQuery = {
-    filter: ""
+    filter: "",
+    queryBuilderType: QueryBuilderType.Simple
 }
diff --git a/src/datasources/asset/types/types.ts b/src/datasources/asset/types/types.ts
index 4d7b8be5..f374b8b6 100644
--- a/src/datasources/asset/types/types.ts
+++ b/src/datasources/asset/types/types.ts
@@ -1,5 +1,6 @@
 import { DataSourceJsonData } from "@grafana/data";
 import { DataQuery } from "@grafana/schema";
+import { QueryBuilderType } from "../constants/constants";
 
 
 export enum AssetQueryType {
@@ -11,12 +12,14 @@ export enum AssetQueryType {
 
 export interface AssetQuery extends DataQuery {
   type: AssetQueryType
+  queryBuilderType: QueryBuilderType
 }
 
 export interface AssetFeatureToggles {
   calibrationForecast: boolean;
   assetList: boolean;
   assetSummary: boolean;
+  advancedFilter: boolean;
 }
 
 export interface AssetDataSourceOptions extends DataSourceJsonData {
@@ -26,7 +29,8 @@ export interface AssetDataSourceOptions extends DataSourceJsonData {
 export const AssetFeatureTogglesDefaults: AssetFeatureToggles = {
   assetList: true,
   calibrationForecast: true,
-  assetSummary: true
+  assetSummary: true,
+  advancedFilter: true
 }
 
 export enum BusType {