gscdump 0.1.3 → 0.3.0

package/dist/query/index.d.mts

@@ -1,45 +1,11 @@
-import "ofetch";
-import { indexing_v3 } from "@googleapis/indexing/v3";
+import _dayjs, { Dayjs } from "dayjs";
 import { searchconsole_v1 } from "@googleapis/searchconsole/v1";
 
 //#region src/core/types.d.ts
-type ApiSite = searchconsole_v1.Schema$WmxSite;
-type ApiSitemap = searchconsole_v1.Schema$WmxSitemap;
-type SearchAnalyticsQuery = searchconsole_v1.Schema$SearchAnalyticsQueryRequest;
-type SearchAnalyticsResponse = searchconsole_v1.Schema$SearchAnalyticsQueryResponse;
-type InspectUrlIndexResponse = searchconsole_v1.Schema$InspectUrlIndexResponse;
-type UrlNotificationMetadata = indexing_v3.Schema$UrlNotificationMetadata;
-type PublishUrlNotificationResponse = indexing_v3.Schema$PublishUrlNotificationResponse;
-//#endregion
-//#region src/core/client.d.ts
 
-interface GoogleSearchConsoleClient {
-  sites: {
-    list: () => Promise<{
-      siteEntry?: ApiSite[];
-    }>;
-  };
-  sitemaps: {
-    list: (siteUrl: string) => Promise<{
-      sitemap?: ApiSitemap[];
-    }>;
-    get: (siteUrl: string, feedpath: string) => Promise<ApiSitemap>;
-    submit: (siteUrl: string, feedpath: string) => Promise<void>;
-    delete: (siteUrl: string, feedpath: string) => Promise<void>;
-  };
-  searchAnalytics: {
-    query: (siteUrl: string, body: SearchAnalyticsQuery) => Promise<SearchAnalyticsResponse>;
-  };
-  urlInspection: {
-    inspect: (siteUrl: string, inspectionUrl: string) => Promise<InspectUrlIndexResponse>;
-  };
-  indexing: {
-    publish: (url: string, type: 'URL_UPDATED' | 'URL_DELETED') => Promise<PublishUrlNotificationResponse>;
-    getMetadata: (url: string) => Promise<UrlNotificationMetadata>;
-  };
-}
+type SearchAnalyticsQuery = searchconsole_v1.Schema$SearchAnalyticsQueryRequest;
 //#endregion
-//#region src/utils/countries.d.ts
+//#region src/query/utils/countries.d.ts
 declare const _default: {
   name: string;
   'alpha-2': string;
@@ -48,18 +14,26 @@ declare const _default: {
 }[];
 //#endregion
 //#region src/query/constants.d.ts
-declare const Device: {
+declare const Devices: {
   readonly MOBILE: "MOBILE";
   readonly DESKTOP: "DESKTOP";
   readonly TABLET: "TABLET";
 };
-type Device = typeof Device[keyof typeof Device];
-declare const Country: { [K in (typeof _default)[number]["alpha-3"]]: Lowercase<K> };
-type Country = typeof Country[keyof typeof Country];
+type Device = typeof Devices[keyof typeof Devices];
+declare const SearchTypes: {
+  readonly WEB: "web";
+  readonly IMAGE: "image";
+  readonly VIDEO: "video";
+  readonly NEWS: "news";
+};
+type SearchType = typeof SearchTypes[keyof typeof SearchTypes];
+declare const Countries: { [K in (typeof _default)[number]["alpha-3"]]: Lowercase<K> };
+type Country = typeof Countries[keyof typeof Countries];
 //#endregion
 //#region src/query/types.d.ts
 interface DimensionValueMap {
   query: string;
+  queryCanonical: string;
   page: string;
   country: Country;
   device: Device;
@@ -67,16 +41,27 @@ interface DimensionValueMap {
   date: string;
 }
 type Dimension = keyof DimensionValueMap;
+interface QueryParamValueMap {
+  searchType: SearchType;
+}
+type QueryParamName = keyof QueryParamValueMap;
 declare const ColumnBrand: unique symbol;
 interface Column<D extends Dimension> {
   readonly [ColumnBrand]: D;
   readonly dimension: D;
 }
+declare const QueryParamBrand: unique symbol;
+interface QueryParam<P extends QueryParamName> {
+  readonly [QueryParamBrand]: P;
+  readonly param: P;
+}
 type FilterOperator = 'equals' | 'notEquals' | 'contains' | 'notContains' | 'includingRegex' | 'excludingRegex';
 type DateOperator = 'gte' | 'gt' | 'lte' | 'lt' | 'between';
+type MetricOperator = 'metricGte' | 'metricGt' | 'metricLte' | 'metricLt' | 'metricBetween';
+type SpecialOperator = 'topLevel';
 interface InternalFilter {
-  dimension: Dimension;
-  operator: FilterOperator | DateOperator;
+  dimension: Dimension | QueryParamName | Metric;
+  operator: FilterOperator | DateOperator | MetricOperator | SpecialOperator;
   expression: string;
   expression2?: string;
 }
@@ -85,10 +70,11 @@ interface Filter<C = object> {
   readonly [FilterBrand]: true;
   readonly _constraints: C;
   readonly _filters: InternalFilter[];
+  readonly _nestedGroups?: Filter<any>[];
   readonly _groupType?: 'and' | 'or';
 }
 type MergeConstraints<F extends Filter<any>[]> = UnionToIntersection<F[number]['_constraints']>;
-type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+type UnionToIntersection<U$1> = (U$1 extends any ? (k: U$1) => void : never) extends ((k: infer I) => void) ? I : never;
 interface GSCResult<D extends Dimension[], C> {
   rows: Array<GSCRow<D, C>>;
 }
@@ -98,24 +84,38 @@ type GSCRow<D extends Dimension[], C> = { [K in D[number]]: K extends keyof C ?
   ctr: number;
   position: number;
 };
+type Metric = 'clicks' | 'impressions' | 'ctr' | 'position';
+declare const MetricColumnBrand: unique symbol;
+interface MetricColumn<M extends Metric> {
+  readonly [MetricColumnBrand]: M;
+  readonly metric: M;
+}
 interface BuilderState {
   dimensions: Dimension[];
-  filters: Filter<any>[];
-  siteUrl?: string;
+  metrics?: Metric[];
+  filter?: Filter<any>;
+  orderBy?: {
+    column: Metric | 'date';
+    dir: 'asc' | 'desc';
+  };
   rowLimit?: number;
   startRow?: number;
 }
 //#endregion
 //#region src/query/builder.d.ts
+type SelectableColumn = Column<Dimension> | MetricColumn<Metric>;
+type OrderableColumn = MetricColumn<Metric> | Column<'date'>;
+type ExtractDimensions<T extends SelectableColumn[]> = { [K in keyof T]: T[K] extends Column<infer D> ? D : never }[number] extends infer U ? Exclude<U, never>[] : never;
 interface GSCQueryBuilder<D extends Dimension[] = [], C = object> {
-  select: <T extends Dimension[]>(...dims: T) => GSCQueryBuilder<T, C>;
+  select: {
+    <T extends Dimension[]>(...dims: T): GSCQueryBuilder<T, C>;
+    <T extends SelectableColumn[]>(...cols: T): GSCQueryBuilder<ExtractDimensions<T> & Dimension[], C>;
+  };
   where: <F extends Filter<any>>(filter: F) => GSCQueryBuilder<D, C & F['_constraints']>;
-  siteUrl: (url: string) => GSCQueryBuilder<D, C>;
+  orderBy: (col: OrderableColumn, dir: 'asc' | 'desc') => GSCQueryBuilder<D, C>;
   limit: (n: number) => GSCQueryBuilder<D, C>;
   offset: (n: number) => GSCQueryBuilder<D, C>;
-  execute: (client: GoogleSearchConsoleClient) => Promise<GSCResult<D, C>>;
   toBody: () => SearchAnalyticsQuery;
-  /** Expose internal state for analysis functions to merge with */
   getState: () => BuilderState;
 }
 declare const gsc: GSCQueryBuilder<[], object>;
@@ -123,13 +123,20 @@ declare const gsc: GSCQueryBuilder<[], object>;
 //#region src/query/columns.d.ts
 declare const page: Column<"page">;
 declare const query: Column<"query">;
+declare const queryCanonical: Column<"queryCanonical">;
 declare const device: Column<"device">;
 declare const country: Column<"country">;
 declare const searchAppearance: Column<"searchAppearance">;
 declare const date: Column<"date">;
+declare const clicks: MetricColumn<"clicks">;
+declare const impressions: MetricColumn<"impressions">;
+declare const ctr: MetricColumn<"ctr">;
+declare const position: MetricColumn<"position">;
+declare const searchType: QueryParam<"searchType">;
 //#endregion
 //#region src/query/operators.d.ts
 declare function eq<D extends Dimension, V extends DimensionValueMap[D]>(column: Column<D>, value: V): Filter<Record<D, V>>;
+declare function eq<P extends QueryParamName, V extends QueryParamValueMap[P]>(param: QueryParam<P>, value: V): Filter<Record<P, V>>;
 declare function ne<D extends Dimension>(column: Column<D>, value: DimensionValueMap[D]): Filter<object>;
 declare function inArray<D extends Dimension, V extends DimensionValueMap[D]>(column: Column<D>, values: readonly V[]): Filter<Record<D, V>>;
 declare function contains<D extends Dimension>(column: Column<D>, pattern: string): Filter<object>;
@@ -139,23 +146,33 @@ declare function notRegex<D extends Dimension>(column: Column<D>, pattern: RegEx
 declare function and<F extends Filter<any>[]>(...filters: F): Filter<MergeConstraints<F>>;
 declare function or<F extends Filter<any>[]>(...filters: F): Filter<object>;
 declare function not<F extends Filter<any>>(filter: F): Filter<object>;
+declare function gte<M extends Metric>(column: MetricColumn<M>, value: number): Filter<object>;
 declare function gte<D extends Dimension>(column: Column<D>, value: DimensionValueMap[D]): Filter<object>;
+declare function gt<M extends Metric>(column: MetricColumn<M>, value: number): Filter<object>;
 declare function gt<D extends Dimension>(column: Column<D>, value: DimensionValueMap[D]): Filter<object>;
+declare function lte<M extends Metric>(column: MetricColumn<M>, value: number): Filter<object>;
 declare function lte<D extends Dimension>(column: Column<D>, value: DimensionValueMap[D]): Filter<object>;
+declare function lt<M extends Metric>(column: MetricColumn<M>, value: number): Filter<object>;
 declare function lt<D extends Dimension>(column: Column<D>, value: DimensionValueMap[D]): Filter<object>;
+declare function between<M extends Metric>(column: MetricColumn<M>, start: number, end: number): Filter<object>;
 declare function between<D extends Dimension>(column: Column<D>, start: DimensionValueMap[D], end: DimensionValueMap[D]): Filter<object>;
+declare function topLevel(column: Column<'page'>): Filter<object>;
 //#endregion
 //#region src/query/resolver.d.ts
-/**
- * Extract date range from filters. Used by analysis functions to get the period.
- */
-declare function extractDateRange(filters: Filter<any>[]): {
+declare function extractDateRange(filter?: Filter<any>): {
   startDate?: string;
   endDate?: string;
 };
+declare function extractMetricFilters(filter?: Filter<any>): InternalFilter[];
+declare function extractSpecialOperatorFilters(filter?: Filter<any>): InternalFilter[];
+//#endregion
+//#region src/query/utils/dayjs.d.ts
+declare function dayjs(date?: _dayjs.ConfigType): Dayjs;
+declare function currentPstDate(): string;
+declare function dayjsPst(): Dayjs;
 //#endregion
 //#region src/query/index.d.ts
 declare function today(): string;
 declare function daysAgo(n: number): string;
 //#endregion
-export { type BuilderState, type Column, Country, type Country as CountryType, Device, type Device as DeviceType, type Dimension, type DimensionValueMap, type Filter, type GSCQueryBuilder, type GSCResult, type GSCRow, and, between, contains, country, date, daysAgo, device, eq, extractDateRange, gsc, gt, gte, inArray, like, lt, lte, ne, not, notRegex, or, page, query, regex, searchAppearance, today };
+export { type BuilderState, type Column, Countries, type Country, type Device, Devices, type Dimension, type DimensionValueMap, type Filter, type GSCQueryBuilder, type GSCResult, type GSCRow, type InternalFilter, type Metric, type MetricColumn, type QueryParam, type QueryParamName, type QueryParamValueMap, type SearchType, SearchTypes, and, between, clicks, contains, country, ctr, currentPstDate, date, dayjs, dayjsPst, daysAgo, device, eq, extractDateRange, extractMetricFilters, extractSpecialOperatorFilters, gsc, gt, gte, impressions, inArray, like, lt, lte, ne, not, notRegex, or, page, position, query, queryCanonical, regex, searchAppearance, searchType, today, topLevel };

package/dist/query/index.mjs

@@ -2,7 +2,7 @@ import _dayjs from "dayjs";
 import timezone from "dayjs/plugin/timezone.js";
 import utc from "dayjs/plugin/utc.js";
 
-//#region src/utils/dayjs.ts
+//#region src/query/utils/dayjs.ts
 _dayjs.extend(utc);
 _dayjs.extend(timezone);
 function dayjs(date$1) {
@@ -24,128 +24,179 @@ const DATE_OPERATORS = [
 	"lt",
 	"between"
 ];
+const METRIC_OPERATORS = [
+	"metricGte",
+	"metricGt",
+	"metricLte",
+	"metricLt",
+	"metricBetween"
+];
+const SPECIAL_OPERATORS = ["topLevel"];
+const QUERY_PARAMS = ["searchType"];
+function isMetricOperator(op) {
+	return METRIC_OPERATORS.includes(op);
+}
+function isSpecialOperator(op) {
+	return SPECIAL_OPERATORS.includes(op);
+}
 function isDateOperator(op) {
 	return DATE_OPERATORS.includes(op);
 }
+function isQueryParam(dim) {
+	return QUERY_PARAMS.includes(dim);
+}
 function addDays(dateStr, days) {
 	const d = new Date(dateStr);
 	d.setDate(d.getDate() + days);
 	return d.toISOString().split("T")[0];
 }
-/**
-* Extract date range from filters. Used by analysis functions to get the period.
-*/
-function extractDateRange(filters) {
-	const { startDate, endDate } = extractDateFilters(filters);
-	return {
-		startDate,
-		endDate
-	};
-}
-function extractDateFilters(filters) {
+function extractSpecialFilters(filter) {
+	if (!filter) return {};
 	let startDate;
 	let endDate;
-	const nonDateFilters = [];
-	for (const filter of filters) {
-		const dateFilters = [];
-		const otherFilters = [];
-		for (const f of filter._filters) if (f.dimension === "date" && isDateOperator(f.operator)) dateFilters.push(f);
-		else otherFilters.push(f);
-		for (const df of dateFilters) switch (df.operator) {
-			case "gte":
-				startDate = df.expression;
-				break;
-			case "gt":
-				startDate = addDays(df.expression, 1);
-				break;
-			case "lte":
-				endDate = df.expression;
-				break;
-			case "lt":
-				endDate = addDays(df.expression, -1);
-				break;
-			case "between":
-				startDate = df.expression;
-				endDate = df.expression2;
-				break;
-		}
-		if (otherFilters.length > 0) nonDateFilters.push({
-			...filter,
-			_filters: otherFilters
-		});
+	let searchType$1;
+	const otherFilters = [];
+	const cleanedNestedGroups = [];
+	for (const f of filter._filters) if (f.dimension === "date" && isDateOperator(f.operator)) switch (f.operator) {
+		case "gte":
+			startDate = f.expression;
+			break;
+		case "gt":
+			startDate = addDays(f.expression, 1);
+			break;
+		case "lte":
+			endDate = f.expression;
+			break;
+		case "lt":
+			endDate = addDays(f.expression, -1);
+			break;
+		case "between":
+			startDate = f.expression;
+			endDate = f.expression2;
+			break;
 	}
+	else if (isQueryParam(f.dimension)) {
+		if (f.dimension === "searchType") searchType$1 = f.expression;
+	} else if (isMetricOperator(f.operator) || isSpecialOperator(f.operator)) otherFilters.push(f);
+	else otherFilters.push(f);
+	if (filter._nestedGroups) for (const nested of filter._nestedGroups) {
+		const extracted = extractSpecialFilters(nested);
+		if (extracted.startDate) startDate = extracted.startDate;
+		if (extracted.endDate) endDate = extracted.endDate;
+		if (extracted.searchType) searchType$1 = extracted.searchType;
+		if (extracted.dimensionFilter) cleanedNestedGroups.push(extracted.dimensionFilter);
+	}
+	const dimensionFilter = otherFilters.length > 0 || cleanedNestedGroups.length > 0 ? {
+		...filter,
+		_filters: otherFilters,
+		_nestedGroups: cleanedNestedGroups.length > 0 ? cleanedNestedGroups : void 0
+	} : void 0;
 	return {
 		startDate,
 		endDate,
-		nonDateFilters
+		searchType: searchType$1,
+		dimensionFilter
+	};
+}
+function extractDateRange(filter) {
+	const { startDate, endDate } = extractSpecialFilters(filter);
+	return {
+		startDate,
+		endDate
 	};
 }
+function extractMetricFilters(filter) {
+	if (!filter) return [];
+	const metricFilters = filter._filters.filter((f) => isMetricOperator(f.operator));
+	const nested = filter._nestedGroups?.flatMap((g) => extractMetricFilters(g)) ?? [];
+	return [...metricFilters, ...nested];
+}
+function extractSpecialOperatorFilters(filter) {
+	if (!filter) return [];
+	const special = filter._filters.filter((f) => isSpecialOperator(f.operator));
+	const nested = filter._nestedGroups?.flatMap((g) => extractSpecialOperatorFilters(g)) ?? [];
+	return [...special, ...nested];
+}
 function resolveToBody(state) {
-	const { startDate, endDate, nonDateFilters } = extractDateFilters(state.filters);
-	if (!startDate || !endDate) throw new Error("Date range required: use .where(between(date, start, end)) or .where(gte(date, start)).where(lte(date, end))");
+	const { startDate, endDate, searchType: searchType$1, dimensionFilter } = extractSpecialFilters(state.filter);
+	if (!startDate || !endDate) throw new Error("Date range required: use .where(between(date, start, end)) or .where(and(gte(date, start), lte(date, end)))");
 	const body = {
 		dimensions: state.dimensions,
 		startDate,
 		endDate
 	};
+	if (searchType$1) body.searchType = searchType$1;
 	if (state.rowLimit) body.rowLimit = state.rowLimit;
 	if (state.startRow) body.startRow = state.startRow;
-	const filterGroups = resolveFilters(nonDateFilters);
+	const filterGroups = resolveFilter(dimensionFilter);
 	if (filterGroups.length > 0) body.dimensionFilterGroups = filterGroups;
 	return body;
 }
-function resolveFilters(filters) {
+function isApiFilter(f) {
+	return !isMetricOperator(f.operator) && !isSpecialOperator(f.operator);
+}
+function resolveFilter(filter) {
+	if (!filter) return [];
 	const groups = [];
-	for (const filter of filters) if ((filter._groupType ?? "and") === "or" && filter._filters.length > 1) groups.push({
-		groupType: "or",
-		filters: filter._filters.map((f) => ({
-			dimension: f.dimension,
-			operator: f.operator,
-			expression: f.expression
-		}))
-	});
-	else if (filter._filters.length > 0) groups.push({ filters: filter._filters.map((f) => ({
+	const groupType = filter._groupType ?? "and";
+	const apiFilters = filter._filters.filter(isApiFilter);
+	if (groupType === "or") {
+		if (apiFilters.length > 0) groups.push({
+			groupType: "or",
+			filters: apiFilters.map((f) => ({
+				dimension: f.dimension,
+				operator: f.operator,
+				expression: f.expression
+			}))
+		});
+	} else if (apiFilters.length > 0) groups.push({ filters: apiFilters.map((f) => ({
 		dimension: f.dimension,
 		operator: f.operator,
 		expression: f.expression
 	})) });
+	if (filter._nestedGroups) for (const nested of filter._nestedGroups) groups.push(...resolveFilter(nested));
 	return groups;
 }
 
 //#endregion
 //#region src/query/builder.ts
-function transformResponse(response, dimensions) {
-	return { rows: (response.rows ?? []).map((row) => {
-		const result = {
-			clicks: row.clicks,
-			impressions: row.impressions,
-			ctr: row.ctr,
-			position: row.position
-		};
-		dimensions.forEach((dim, i) => {
-			result[dim] = row.keys?.[i];
-		});
-		return result;
-	}) };
+function isDimensionString(v) {
+	return typeof v === "string";
+}
+function isMetricColumn(v) {
+	return typeof v === "object" && v !== null && "metric" in v;
+}
+function isDimensionColumn(v) {
+	return typeof v === "object" && v !== null && "dimension" in v && !("metric" in v);
 }
 function createBuilder(state) {
 	return {
-		select(...dims) {
+		select(...args) {
+			const dimensions = [];
+			const metrics = [];
+			for (const arg of args) if (isDimensionString(arg)) dimensions.push(arg);
+			else if (isDimensionColumn(arg)) dimensions.push(arg.dimension);
+			else if (isMetricColumn(arg)) metrics.push(arg.metric);
 			return createBuilder({
 				...state,
-				dimensions: dims
+				dimensions,
+				metrics: metrics.length > 0 ? metrics : void 0
 			});
 		},
 		where(filter) {
 			return createBuilder({
 				...state,
-				filters: [...state.filters, filter]
+				filter
 			});
 		},
-		siteUrl(url) {
+		orderBy(col, dir) {
+			const column = isMetricColumn(col) ? col.metric : col.dimension;
 			return createBuilder({
 				...state,
-				siteUrl: url
+				orderBy: {
+					column,
+					dir
+				}
 			});
 		},
 		limit(n) {
@@ -160,10 +211,6 @@ function createBuilder(state) {
 				startRow: n
 			});
 		},
-		async execute(client) {
-			const body = resolveToBody(state);
-			return transformResponse(await client.searchAnalytics.query(state.siteUrl, body), state.dimensions);
-		},
 		toBody() {
 			return resolveToBody(state);
 		},
@@ -172,25 +219,34 @@ function createBuilder(state) {
 		}
 	};
 }
-const gsc = createBuilder({
-	dimensions: [],
-	filters: []
-});
+const gsc = createBuilder({ dimensions: [] });
 
 //#endregion
 //#region src/query/columns.ts
 function createColumn(dimension) {
 	return { dimension };
 }
+function createMetricColumn(metric) {
+	return { metric };
+}
+function createQueryParam(param) {
+	return { param };
+}
 const page = createColumn("page");
 const query = createColumn("query");
+const queryCanonical = createColumn("queryCanonical");
 const device = createColumn("device");
 const country = createColumn("country");
 const searchAppearance = createColumn("searchAppearance");
 const date = createColumn("date");
+const clicks = createMetricColumn("clicks");
+const impressions = createMetricColumn("impressions");
+const ctr = createMetricColumn("ctr");
+const position = createMetricColumn("position");
+const searchType = createQueryParam("searchType");
 
 //#endregion
-//#region src/utils/countries.ts
+//#region src/query/utils/countries.ts
 var countries_default = [
 	{
 		"name": "Afghanistan",
@@ -1690,20 +1746,26 @@ var countries_default = [
 
 //#endregion
 //#region src/query/constants.ts
-const Device = {
+const Devices = {
 	MOBILE: "MOBILE",
 	DESKTOP: "DESKTOP",
 	TABLET: "TABLET"
 };
-const Country = Object.fromEntries(countries_default.map((c) => [c["alpha-3"], c["alpha-3"].toLowerCase()]));
+const SearchTypes = {
+	WEB: "web",
+	IMAGE: "image",
+	VIDEO: "video",
+	NEWS: "news"
+};
+const Countries = Object.fromEntries(countries_default.map((c) => [c["alpha-3"], c["alpha-3"].toLowerCase()]));
 
 //#endregion
 //#region src/query/operators.ts
-function eq(column, value) {
+function eq(columnOrParam, value) {
 	return {
 		_constraints: {},
 		_filters: [{
-			dimension: column.dimension,
+			dimension: "dimension" in columnOrParam ? columnOrParam.dimension : columnOrParam.param,
 			operator: "equals",
 			expression: String(value)
 		}]
@@ -1771,9 +1833,17 @@ function notRegex(column, pattern) {
 	};
 }
 function and(...filters) {
+	const flatFilters = [];
+	const nestedGroups = [];
+	for (const f of filters) if (f._groupType === "or") nestedGroups.push(f);
+	else {
+		flatFilters.push(...f._filters);
+		if (f._nestedGroups) nestedGroups.push(...f._nestedGroups);
+	}
 	return {
 		_constraints: {},
-		_filters: filters.flatMap((f) => f._filters),
+		_filters: flatFilters,
+		_nestedGroups: nestedGroups.length > 0 ? nestedGroups : void 0,
 		_groupType: "and"
 	};
 }
@@ -1811,6 +1881,14 @@ function invertOperator(op) {
 	}[op];
 }
 function gte(column, value) {
+	if ("metric" in column) return {
+		_constraints: {},
+		_filters: [{
+			dimension: column.metric,
+			operator: "metricGte",
+			expression: String(value)
+		}]
+	};
 	return {
 		_constraints: {},
 		_filters: [{
@@ -1821,6 +1899,14 @@ function gte(column, value) {
 	};
 }
 function gt(column, value) {
+	if ("metric" in column) return {
+		_constraints: {},
+		_filters: [{
+			dimension: column.metric,
+			operator: "metricGt",
+			expression: String(value)
+		}]
+	};
 	return {
 		_constraints: {},
 		_filters: [{
@@ -1831,6 +1917,14 @@ function gt(column, value) {
 	};
 }
 function lte(column, value) {
+	if ("metric" in column) return {
+		_constraints: {},
+		_filters: [{
+			dimension: column.metric,
+			operator: "metricLte",
+			expression: String(value)
+		}]
+	};
 	return {
 		_constraints: {},
 		_filters: [{
@@ -1841,6 +1935,14 @@ function lte(column, value) {
 	};
 }
 function lt(column, value) {
+	if ("metric" in column) return {
+		_constraints: {},
+		_filters: [{
+			dimension: column.metric,
+			operator: "metricLt",
+			expression: String(value)
+		}]
+	};
 	return {
 		_constraints: {},
 		_filters: [{
@@ -1851,6 +1953,15 @@ function lt(column, value) {
 	};
 }
 function between(column, start, end) {
+	if ("metric" in column) return {
+		_constraints: {},
+		_filters: [{
+			dimension: column.metric,
+			operator: "metricBetween",
+			expression: String(start),
+			expression2: String(end)
+		}]
+	};
 	return {
 		_constraints: {},
 		_filters: [{
@@ -1861,6 +1972,16 @@ function between(column, start, end) {
 		}]
 	};
 }
+function topLevel(column) {
+	return {
+		_constraints: {},
+		_filters: [{
+			dimension: column.dimension,
+			operator: "topLevel",
+			expression: ""
+		}]
+	};
+}
 
 //#endregion
 //#region src/query/index.ts
@@ -1872,4 +1993,4 @@ function daysAgo(n) {
 }
 
 //#endregion
-export { Country, Device, and, between, contains, country, date, daysAgo, device, eq, extractDateRange, gsc, gt, gte, inArray, like, lt, lte, ne, not, notRegex, or, page, query, regex, searchAppearance, today };
+export { Countries, Devices, SearchTypes, and, between, clicks, contains, country, ctr, currentPstDate, date, dayjs, dayjsPst, daysAgo, device, eq, extractDateRange, extractMetricFilters, extractSpecialOperatorFilters, gsc, gt, gte, impressions, inArray, like, lt, lte, ne, not, notRegex, or, page, position, query, queryCanonical, regex, searchAppearance, searchType, today, topLevel };