gscdump 1.3.2 → 1.4.1

package/dist/{_chunks/resolver.mjs → query/utils/countries.mjs}

@@ -1,5 +1,3 @@
-import { err, ok, unwrapResult } from "../core/result.mjs";
-import { addDays } from "./gsc-dates.mjs";
 var countries_default = [
 	{
 		"name": "Afghanistan",
@@ -1496,435 +1494,4 @@ var countries_default = [
 		"country-code": "716"
 	}
 ];
-const Devices = {
-	MOBILE: "MOBILE",
-	DESKTOP: "DESKTOP",
-	TABLET: "TABLET"
-};
-const SearchTypes = {
-	WEB: "web",
-	IMAGE: "image",
-	VIDEO: "video",
-	NEWS: "news",
-	DISCOVER: "discover",
-	GOOGLE_NEWS: "googleNews"
-};
-const Countries = Object.fromEntries(countries_default.map((c) => [c["alpha-3"], c["alpha-3"].toLowerCase()]));
-const TIME_AXIS_DIMENSIONS = /* @__PURE__ */ new Set(["date", "hour"]);
-const queryErrors = {
-	missingDateRange() {
-		return {
-			kind: "missing-date-range",
-			message: "Date range required: use .where(between(date, start, end)) or .where(and(gte(date, start), lte(date, end)))"
-		};
-	},
-	invalidRowLimit(value) {
-		return {
-			kind: "invalid-row-limit",
-			value,
-			message: `rowLimit must be a positive integer, got ${value}`
-		};
-	},
-	invalidStartRow(value) {
-		return {
-			kind: "invalid-start-row",
-			value,
-			message: `startRow must be a non-negative integer, got ${value}`
-		};
-	},
-	hourDimensionRequiresHourlyState() {
-		return {
-			kind: "invalid-data-state",
-			message: "hour dimension requires dataState: \"hourly_all\""
-		};
-	},
-	hourlyStateRequiresHourDimension() {
-		return {
-			kind: "invalid-data-state",
-			message: "dataState: \"hourly_all\" requires grouping by hour dimension"
-		};
-	},
-	byPropertyUnsupportedSearchType() {
-		return {
-			kind: "invalid-aggregation-type",
-			message: "aggregationType: \"byProperty\" is not supported for type \"discover\" or \"googleNews\""
-		};
-	},
-	byPropertyNotAllowedWithPage() {
-		return {
-			kind: "invalid-aggregation-type",
-			message: "aggregationType: \"byProperty\" is not allowed when grouping or filtering by page"
-		};
-	},
-	byNewsShowcaseRequiresSearchType() {
-		return {
-			kind: "invalid-aggregation-type",
-			message: "aggregationType: \"byNewsShowcasePanel\" requires type \"discover\" or \"googleNews\""
-		};
-	},
-	byNewsShowcaseNotAllowedWithPage() {
-		return {
-			kind: "invalid-aggregation-type",
-			message: "aggregationType: \"byNewsShowcasePanel\" is not allowed when grouping or filtering by page"
-		};
-	},
-	byNewsShowcaseRequiresShowcaseFilter() {
-		return {
-			kind: "invalid-aggregation-type",
-			message: "aggregationType: \"byNewsShowcasePanel\" requires a searchAppearance equals \"NEWS_SHOWCASE\" filter and no other searchAppearance filter"
-		};
-	},
-	invalidBuilderState(cause) {
-		return {
-			kind: "invalid-builder-state",
-			cause,
-			message: "Invalid state"
-		};
-	},
-	malformedFilterLeaf() {
-		return {
-			kind: "invalid-filter",
-			message: "Malformed filter: each filter leaf requires a string `dimension` and `operator`"
-		};
-	},
-	unsupportedCapability(capability, context) {
-		return {
-			kind: "unsupported-capability",
-			capability,
-			context,
-			message: `${context} requires ${capability} capability`
-		};
-	},
-	unresolvableDataset(dimensions, filterDims = []) {
-		const grouped = dimensions.filter((d) => !TIME_AXIS_DIMENSIONS.has(d));
-		const filtered = filterDims.filter((d) => !TIME_AXIS_DIMENSIONS.has(d));
-		return {
-			kind: "unresolvable-dataset",
-			dimensions,
-			filterDims,
-			message: `Cannot resolve a [${grouped.join(", ")}] breakdown filtered by [${filtered.join(", ")}] from stored data: these dimensions live in separate per-dimension tables. Only the live GSC API computes cross-dimension aggregates.`
-		};
-	}
-};
-const QUERY_ERROR_KINDS = /* @__PURE__ */ new Set([
-	"missing-date-range",
-	"invalid-row-limit",
-	"invalid-start-row",
-	"invalid-data-state",
-	"invalid-aggregation-type",
-	"invalid-builder-state",
-	"invalid-filter",
-	"unsupported-capability",
-	"unresolvable-dataset"
-]);
-function isQueryError(value) {
-	return typeof value === "object" && value !== null && QUERY_ERROR_KINDS.has(value.kind) && typeof value.message === "string";
-}
-var UnsupportedLogicalCapabilityError = class extends Error {
-	queryError;
-	constructor(capability, context) {
-		const error = queryErrors.unsupportedCapability(capability, context);
-		super(error.message);
-		this.name = "UnsupportedLogicalCapabilityError";
-		this.queryError = error;
-	}
-};
-var UnresolvableDatasetError = class extends Error {
-	queryError;
-	constructor(dimensions, filterDims = []) {
-		const error = queryErrors.unresolvableDataset(dimensions, filterDims);
-		super(error.message);
-		this.name = "UnresolvableDatasetError";
-		this.queryError = error;
-	}
-};
-function queryErrorToException(error) {
-	switch (error.kind) {
-		case "unsupported-capability": return new UnsupportedLogicalCapabilityError(error.capability, error.context);
-		case "unresolvable-dataset": return new UnresolvableDatasetError(error.dimensions, error.filterDims);
-		default: {
-			const exception = new Error(error.message);
-			if ("cause" in error && error.cause !== void 0) exception.cause = error.cause;
-			exception.queryError = error;
-			return exception;
-		}
-	}
-}
-const DATE_OPERATORS = [
-	"gte",
-	"gt",
-	"lte",
-	"lt",
-	"between"
-];
-const METRIC_OPERATORS = [
-	"metricGte",
-	"metricGt",
-	"metricLte",
-	"metricLt",
-	"metricBetween"
-];
-const SPECIAL_OPERATORS = ["topLevel"];
-const QUERY_PARAMS = ["searchType"];
-const FILTER_METRICS = [
-	"clicks",
-	"impressions",
-	"ctr",
-	"position"
-];
-function isDateOperator(op) {
-	return DATE_OPERATORS.includes(op);
-}
-function isMetricOperator(op) {
-	return METRIC_OPERATORS.includes(op);
-}
-function isSpecialOperator(op) {
-	return SPECIAL_OPERATORS.includes(op);
-}
-function isQueryParam(value) {
-	return QUERY_PARAMS.includes(value);
-}
-function isMetric(value) {
-	return FILTER_METRICS.includes(value);
-}
-function isRegexOperator(op) {
-	return op === "includingRegex" || op === "excludingRegex";
-}
-const KNOWN_SEARCH_TYPES = new Set(Object.values(SearchTypes));
-function isWireGroupType(type) {
-	return type === "and" || type === "or";
-}
-function convertWireLeaf(alt) {
-	if (!alt.column || !alt.type || isWireGroupType(alt.type)) return null;
-	const f = {
-		dimension: alt.column,
-		operator: alt.type,
-		expression: alt.type === "between" ? alt.from ?? "" : alt.value ?? ""
-	};
-	if (alt.type === "between" && alt.to) f.expression2 = alt.to;
-	return f;
-}
-function convertWireGroup(alt) {
-	if (!isWireGroupType(alt.type)) {
-		const leaf = convertWireLeaf(alt);
-		return leaf ? { _filters: [leaf] } : null;
-	}
-	const leaves = [];
-	const nested = [];
-	for (const child of alt.filters ?? []) if (isWireGroupType(child.type)) {
-		const sub = convertWireGroup(child);
-		if (sub) nested.push(sub);
-	} else {
-		const leaf = convertWireLeaf(child);
-		if (leaf) leaves.push(leaf);
-	}
-	if (leaves.length === 0 && nested.length === 0) return null;
-	return {
-		_filters: leaves,
-		_nestedGroups: nested.length > 0 ? nested : void 0,
-		_groupType: alt.type
-	};
-}
-function isWireFilter(input) {
-	if (!input || typeof input !== "object") return false;
-	const o = input;
-	if ("_filters" in o) return false;
-	return "type" in o && typeof o.type === "string" || "filters" in o && Array.isArray(o.filters);
-}
-function normalizeFilter(input) {
-	if (!input) return void 0;
-	if (isWireFilter(input)) return convertWireGroup(input) ?? void 0;
-	if (typeof input === "object" && Array.isArray(input._filters)) return input;
-}
-function normalizeOrderBy(orderBy) {
-	const spec = Array.isArray(orderBy) ? orderBy[0] : orderBy;
-	if (!spec || typeof spec !== "object") return void 0;
-	const o = spec;
-	if (typeof o.column !== "string" || o.column.length === 0) return void 0;
-	const dir = typeof o.dir === "string" ? o.dir.toLowerCase() === "asc" ? "asc" : "desc" : o.desc === false ? "asc" : "desc";
-	return {
-		column: o.column,
-		dir
-	};
-}
-function hasMalformedFilterLeaf(filter) {
-	if (!filter || typeof filter !== "object") return false;
-	if (Array.isArray(filter._filters)) {
-		for (const leaf of filter._filters) if (!leaf || typeof leaf !== "object" || typeof leaf.operator !== "string" || typeof leaf.dimension !== "string") return true;
-	}
-	if (Array.isArray(filter._nestedGroups)) {
-		for (const group of filter._nestedGroups) if (hasMalformedFilterLeaf(group)) return true;
-	}
-	return false;
-}
-function normalizeBuilderStateResult(state) {
-	if (!state || typeof state !== "object") return err(queryErrors.invalidBuilderState(state));
-	const s = state;
-	const filter = normalizeFilter(s.filter);
-	if (hasMalformedFilterLeaf(filter)) return err(queryErrors.malformedFilterLeaf());
-	const normalized = {
-		dimensions: Array.isArray(s.dimensions) ? s.dimensions : [],
-		metrics: s.metrics,
-		filter,
-		orderBy: normalizeOrderBy(s.orderBy),
-		rowLimit: s.rowLimit,
-		startRow: s.startRow,
-		dataState: s.dataState,
-		aggregationType: s.aggregationType
-	};
-	if (typeof s.searchType === "string" && KNOWN_SEARCH_TYPES.has(s.searchType)) normalized.searchType = s.searchType;
-	return ok(normalized);
-}
-function normalizeBuilderState(state) {
-	return unwrapResult(normalizeBuilderStateResult(state), queryErrorToException);
-}
-function extractSpecialFilters(filter) {
-	if (!filter || !Array.isArray(filter._filters)) return {};
-	let startDate;
-	let endDate;
-	let searchType;
-	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 = 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 (!startDate && extracted.startDate) startDate = extracted.startDate;
-		if (!endDate && extracted.endDate) endDate = extracted.endDate;
-		if (!searchType && extracted.searchType) searchType = 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,
-		searchType,
-		dimensionFilter
-	};
-}
-function extractDateRange(input) {
-	const { startDate, endDate } = extractSpecialFilters(normalizeFilter(input));
-	return {
-		startDate,
-		endDate
-	};
-}
-function extractMetricFilters(input) {
-	const filter = normalizeFilter(input);
-	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(input) {
-	const filter = normalizeFilter(input);
-	if (!filter) return [];
-	const special = filter._filters.filter((f) => isSpecialOperator(f.operator));
-	const nested = filter._nestedGroups?.flatMap((g) => extractSpecialOperatorFilters(g)) ?? [];
-	return [...special, ...nested];
-}
-function extractSearchType(state) {
-	if (!state) return void 0;
-	if (state.searchType && KNOWN_SEARCH_TYPES.has(state.searchType)) return state.searchType;
-	const filter = state.filter;
-	const raw = extractSpecialFilters(normalizeFilter(filter)).searchType;
-	if (typeof raw !== "string" || raw.length === 0) return void 0;
-	return KNOWN_SEARCH_TYPES.has(raw) ? raw : void 0;
-}
-function resolveToBodyResult(state) {
-	const { startDate, endDate, searchType, dimensionFilter } = extractSpecialFilters(state.filter);
-	if (!startDate || !endDate) return err(queryErrors.missingDateRange());
-	const body = {
-		dimensions: state.dimensions,
-		startDate,
-		endDate
-	};
-	const resolvedType = state.searchType ?? searchType;
-	if (resolvedType) body.type = resolvedType;
-	if (state.rowLimit !== void 0) {
-		if (!Number.isInteger(state.rowLimit) || state.rowLimit < 1) return err(queryErrors.invalidRowLimit(state.rowLimit));
-		body.rowLimit = state.rowLimit;
-	}
-	if (state.startRow !== void 0) {
-		if (!Number.isInteger(state.startRow) || state.startRow < 0) return err(queryErrors.invalidStartRow(state.startRow));
-		if (state.startRow > 0) body.startRow = state.startRow;
-	}
-	const hasHour = state.dimensions?.includes("hour");
-	if (hasHour && state.dataState !== "hourly_all") return err(queryErrors.hourDimensionRequiresHourlyState());
-	if (state.dataState === "hourly_all" && !hasHour) return err(queryErrors.hourlyStateRequiresHourDimension());
-	if (state.dataState) body.dataState = state.dataState;
-	const filterGroups = resolveFilter(dimensionFilter);
-	if (filterGroups.length > 0) body.dimensionFilterGroups = filterGroups;
-	if (state.aggregationType) {
-		const groupsByPage = (body.dimensions ?? []).includes("page");
-		const apiLeafFilters = filterGroups.flatMap((g) => g.filters ?? []);
-		const filtersByPage = apiLeafFilters.some((f) => f.dimension === "page");
-		if (state.aggregationType === "byProperty") {
-			if (body.type === "discover" || body.type === "googleNews") return err(queryErrors.byPropertyUnsupportedSearchType());
-			if (groupsByPage || filtersByPage) return err(queryErrors.byPropertyNotAllowedWithPage());
-		}
-		if (state.aggregationType === "byNewsShowcasePanel") {
-			if (body.type !== "discover" && body.type !== "googleNews") return err(queryErrors.byNewsShowcaseRequiresSearchType());
-			if (groupsByPage || filtersByPage) return err(queryErrors.byNewsShowcaseNotAllowedWithPage());
-			const saFilters = apiLeafFilters.filter((f) => f.dimension === "searchAppearance");
-			const hasNewsShowcase = saFilters.some((f) => f.operator === "equals" && f.expression === "NEWS_SHOWCASE");
-			const hasOther = saFilters.some((f) => !(f.operator === "equals" && f.expression === "NEWS_SHOWCASE"));
-			if (!hasNewsShowcase || hasOther) return err(queryErrors.byNewsShowcaseRequiresShowcaseFilter());
-		}
-		body.aggregationType = state.aggregationType;
-	}
-	return ok(body);
-}
-function resolveToBody(state) {
-	return unwrapResult(resolveToBodyResult(state), queryErrorToException);
-}
-function isApiFilter(f) {
-	return !isMetricOperator(f.operator) && !isSpecialOperator(f.operator);
-}
-function resolveFilter(filter) {
-	if (!filter) return [];
-	const groups = [];
-	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;
-}
-export { Countries, DATE_OPERATORS, Devices, SearchTypes, UnresolvableDatasetError, UnsupportedLogicalCapabilityError, extractDateRange, extractMetricFilters, extractSearchType, extractSpecialOperatorFilters, isDateOperator, isMetric, isQueryError, isQueryParam, isRegexOperator, normalizeBuilderState, normalizeBuilderStateResult, normalizeFilter, queryErrorToException, queryErrors, resolveToBody, resolveToBodyResult };
+export { countries_default as default };

package/dist/{_chunks → query/utils}/dayjs.mjs

@@ -1,5 +1,4 @@
-import { format } from "date-fns/format";
-import { subDays } from "date-fns/subDays";
+import { addDays } from "../../core/gsc-dates.mjs";
 let pstFormatter;
 function getPstFormatter() {
 	pstFormatter ??= new Intl.DateTimeFormat("en-CA", {
@@ -24,7 +23,6 @@ function currentPstDate() {
 	return `${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
 }
 function daysAgoPst(n) {
-	const { year, month, day } = pstDateParts();
-	return format(subDays(new Date(year, month - 1, day, 12), n), "yyyy-MM-dd");
+	return addDays(currentPstDate(), -n);
 }
 export { currentPstDate, daysAgoPst };

package/dist/sitemap.d.mts

@@ -0,0 +1,26 @@
+interface DiscoverSitemapOptions {
+  /** User-Agent sent on the discovery requests. */
+  userAgent?: string;
+  /** AbortSignal threaded through fetches; defaults to a 10s timeout per call. */
+  signal?: AbortSignal;
+}
+/**
+ * Try to discover a sitemap for `domain` by checking robots.txt for a
+ * `Sitemap:` directive, then a small set of common paths. Returns the first
+ * URL that responds with a 2xx, or `null`.
+ */
+declare function discoverSitemap(domain: string, options?: DiscoverSitemapOptions): Promise<string | null>;
+interface FetchSitemapUrlsOptions extends DiscoverSitemapOptions {
+  /** Maximum nested sitemap-index depth to follow. Default 3. */
+  maxDepth?: number;
+  /** Stop after this many URLs (across all nested sitemaps). Default unlimited. */
+  limit?: number;
+}
+/**
+ * Fetch a sitemap (or sitemap index) and return the list of `<loc>` URLs.
+ * Sitemap-index files are followed up to `maxDepth` levels. Duplicates are
+ * de-duplicated. The XML parser is regex-based — it handles the common
+ * `<loc>https://...</loc>` shape but doesn't validate the schema.
+ */
+declare function fetchSitemapUrls(sitemapUrl: string, options?: FetchSitemapUrlsOptions): Promise<string[]>;
+export { DiscoverSitemapOptions, FetchSitemapUrlsOptions, discoverSitemap, fetchSitemapUrls };

package/dist/sitemap.mjs

@@ -0,0 +1,70 @@
+const FETCH_TIMEOUT_MS = 1e4;
+const COMMON_PATHS = ["/sitemap.xml", "/sitemap_index.xml"];
+const SITEMAP_DIRECTIVE_RE = /^Sitemap:\s*(\S+)/im;
+async function discoverSitemap(domain, options = {}) {
+	const userAgent = options.userAgent ?? "gscdump sitemap fetcher";
+	const baseUrl = `https://${domain}`;
+	const signalFor = () => options.signal ?? AbortSignal.timeout(FETCH_TIMEOUT_MS);
+	const robotsRes = await fetch(`${baseUrl}/robots.txt`, {
+		headers: { "User-Agent": userAgent },
+		signal: signalFor()
+	}).catch(() => null);
+	if (robotsRes?.ok) {
+		const match = (await robotsRes.text()).match(SITEMAP_DIRECTIVE_RE);
+		if (match?.[1]) {
+			if ((await fetch(match[1], {
+				method: "HEAD",
+				signal: signalFor()
+			}).catch(() => null))?.ok) return match[1];
+		}
+	}
+	for (const path of COMMON_PATHS) {
+		const url = `${baseUrl}${path}`;
+		if ((await fetch(url, {
+			method: "HEAD",
+			headers: { "User-Agent": userAgent },
+			signal: signalFor()
+		}).catch(() => null))?.ok) return url;
+	}
+	return null;
+}
+const LOC_RE = /<loc>([^<]+)<\/loc>/gi;
+const SITEMAPINDEX_RE = /<sitemapindex\b/i;
+async function fetchSitemapUrls(sitemapUrl, options = {}) {
+	const userAgent = options.userAgent ?? "gscdump sitemap fetcher";
+	const maxDepth = options.maxDepth ?? 3;
+	const limit = options.limit;
+	const signalFor = () => options.signal ?? AbortSignal.timeout(FETCH_TIMEOUT_MS);
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	const visit = async (url, depth) => {
+		if (limit != null && out.length >= limit) return;
+		if (depth > maxDepth) return;
+		const res = await fetch(url, {
+			headers: { "User-Agent": userAgent },
+			signal: signalFor()
+		});
+		if (!res.ok) throw new Error(`Fetch ${url} failed: ${res.status}`);
+		const text = await res.text();
+		if (SITEMAPINDEX_RE.test(text)) {
+			for (const match of text.matchAll(LOC_RE)) {
+				if (limit != null && out.length >= limit) return;
+				const child = match[1].trim();
+				if (!child) continue;
+				await visit(child, depth + 1);
+			}
+			return;
+		}
+		for (const match of text.matchAll(LOC_RE)) {
+			const u = match[1].trim();
+			if (!u) continue;
+			if (seen.has(u)) continue;
+			seen.add(u);
+			out.push(u);
+			if (limit != null && out.length >= limit) return;
+		}
+	};
+	await visit(sitemapUrl, 0);
+	return out;
+}
+export { discoverSitemap, fetchSitemapUrls };

package/dist/url.d.mts

@@ -0,0 +1,9 @@
+/**
+ * Equivalence key for matching two URLs that point at the same resource
+ * across protocol (http/https), www. prefix, trailing slash, and casing.
+ * Returns `null` for unparseable input.
+ *
+ * Example: `https://www.Example.com/Foo/` → `example.com/foo`
+ */
+declare function urlMatchKey(url: string): string | null;
+export { urlMatchKey };

package/dist/url.mjs

@@ -0,0 +1,6 @@
+function urlMatchKey(url) {
+	const u = URL.parse(url);
+	if (!u) return null;
+	return [u.hostname.replace(/^www\./, ""), u.pathname.replace(/\/$/, "") || "/"].join("").toLowerCase();
+}
+export { urlMatchKey };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "gscdump",
   "type": "module",
-  "version": "1.3.2",
+  "version": "1.4.1",
   "description": "Direct Google Search Console client with typed queries, streaming pagination, URL inspection, and indexing helpers",
   "author": {
     "name": "Harlan Wilton",
@@ -82,9 +82,8 @@
     "node": ">=22"
   },
   "dependencies": {
-    "date-fns": "^4.4.0",
     "ofetch": "^1.5.1",
-    "@gscdump/contracts": "^1.3.2"
+    "@gscdump/contracts": "^1.4.1"
   },
   "scripts": {
     "dev": "obuild --stub",

package/dist/_chunks/contracts.d.mts

@@ -1,47 +0,0 @@
-import { ColumnDef, ColumnType, Row, TableName, TableSchema, TenantCtx } from "@gscdump/contracts";
-type GscSearchAnalyticsDimension = 'page' | 'query' | 'country' | 'device' | 'date' | 'hour' | 'searchAppearance';
-type GscDataState = 'final' | 'all' | 'hourly_all';
-interface GscSearchAnalyticsMetadata {
-  /** First date (YYYY-MM-DD, PT) still being collected. Populated when dataState=`all` and grouped by `date`. */
-  first_incomplete_date?: string;
-  /** First hour (YYYY-MM-DDThh:mm:ss±hh:mm, PT) still being collected. Populated when dataState=`hourly_all` and grouped by `hour`. */
-  first_incomplete_hour?: string;
-}
-type GscSearchAnalyticsFilterOperator = 'equals' | 'notEquals' | 'contains' | 'notContains' | 'includingRegex' | 'excludingRegex';
-interface GscSearchAnalyticsFilter {
-  dimension: GscSearchAnalyticsDimension;
-  expression: string;
-  operator?: GscSearchAnalyticsFilterOperator;
-}
-interface GscSearchAnalyticsFilterGroup {
-  groupType?: 'and' | 'or';
-  filters: GscSearchAnalyticsFilter[];
-}
-type GscSearchType = 'web' | 'image' | 'video' | 'news' | 'discover' | 'googleNews';
-type GscAggregationType = 'auto' | 'byPage' | 'byProperty' | 'byNewsShowcasePanel';
-type GscResponseAggregationType = 'auto' | 'byPage' | 'byProperty' | 'byNewsShowcasePanel';
-interface GscSearchAnalyticsRequest {
-  startDate: string;
-  endDate: string;
-  dimensions?: GscSearchAnalyticsDimension[];
-  dimensionFilterGroups?: GscSearchAnalyticsFilterGroup[];
-  rowLimit?: number;
-  startRow?: number;
-  /** GSC search corpus. Maps to wire field `type` (the API still accepts the deprecated `searchType` alias). */
-  type?: GscSearchType;
-  dataState?: GscDataState;
-  aggregationType?: GscAggregationType;
-}
-interface GscSearchAnalyticsRow {
-  keys: string[];
-  clicks: number;
-  impressions: number;
-  ctr: number;
-  position: number;
-}
-interface GscSearchAnalyticsResponse {
-  rows?: GscSearchAnalyticsRow[];
-  responseAggregationType?: GscResponseAggregationType;
-  metadata?: GscSearchAnalyticsMetadata;
-}
-export { type ColumnDef, type ColumnType, GscAggregationType, GscDataState, GscResponseAggregationType, GscSearchAnalyticsDimension, GscSearchAnalyticsFilter, GscSearchAnalyticsFilterGroup, GscSearchAnalyticsFilterOperator, GscSearchAnalyticsMetadata, GscSearchAnalyticsRequest, GscSearchAnalyticsResponse, GscSearchAnalyticsRow, GscSearchType, type Row, type TableName, type TableSchema, type TenantCtx };