gscdump 1.4.0 → 1.4.2

package/dist/onboarding.d.mts

@@ -0,0 +1,2 @@
+import { AccountNextAction, AccountStatus, AnalyticsNextAction, AnalyticsStatus, GSCDUMP_ONBOARDING_CONTRACT_VERSION, GSCDUMP_OPTIONAL_INDEXING_SCOPE, GSCDUMP_REQUIRED_ANALYTICS_SCOPE, GSCDUMP_WRITE_ANALYTICS_SCOPE, IndexingNextAction, IndexingStatus, LifecycleError, LifecycleErrorCode, LifecycleProgress, LifecycleWebhookEnvelope, LifecycleWebhookEvent, PartnerLifecycleAccount, PartnerLifecycleResponse, PartnerLifecycleSite, PropertyNextAction, PropertyStatus, QuerySourceMode, SitemapNextAction, SitemapStatus, accountNextActions, accountStatuses, analyticsNextActions, analyticsStatuses, hasOptionalIndexingScope, hasRequiredAnalyticsScope, indexingNextActions, indexingStatuses, lifecycleErrorCodes, parseGrantedScopes, propertyNextActions, propertyStatuses, querySourceModes, sitemapNextActions, sitemapStatuses } from "@gscdump/contracts/partner";
+export { type AccountNextAction, type AccountStatus, type AnalyticsNextAction, type AnalyticsStatus, GSCDUMP_ONBOARDING_CONTRACT_VERSION, GSCDUMP_OPTIONAL_INDEXING_SCOPE, GSCDUMP_REQUIRED_ANALYTICS_SCOPE, GSCDUMP_WRITE_ANALYTICS_SCOPE, type IndexingNextAction, type IndexingStatus, type LifecycleError, type LifecycleErrorCode, type LifecycleProgress, type LifecycleWebhookEnvelope, type LifecycleWebhookEvent, type PartnerLifecycleAccount, type PartnerLifecycleResponse, type PartnerLifecycleSite, type PropertyNextAction, type PropertyStatus, type QuerySourceMode, type SitemapNextAction, type SitemapStatus, accountNextActions, accountStatuses, analyticsNextActions, analyticsStatuses, hasOptionalIndexingScope, hasRequiredAnalyticsScope, indexingNextActions, indexingStatuses, lifecycleErrorCodes, parseGrantedScopes, propertyNextActions, propertyStatuses, querySourceModes, sitemapNextActions, sitemapStatuses };

package/dist/onboarding.mjs

@@ -0,0 +1,2 @@
+import { GSCDUMP_ONBOARDING_CONTRACT_VERSION, GSCDUMP_OPTIONAL_INDEXING_SCOPE, GSCDUMP_REQUIRED_ANALYTICS_SCOPE, GSCDUMP_WRITE_ANALYTICS_SCOPE, accountNextActions, accountStatuses, analyticsNextActions, analyticsStatuses, hasOptionalIndexingScope, hasRequiredAnalyticsScope, indexingNextActions, indexingStatuses, lifecycleErrorCodes, parseGrantedScopes, propertyNextActions, propertyStatuses, querySourceModes, sitemapNextActions, sitemapStatuses } from "@gscdump/contracts/partner";
+export { GSCDUMP_ONBOARDING_CONTRACT_VERSION, GSCDUMP_OPTIONAL_INDEXING_SCOPE, GSCDUMP_REQUIRED_ANALYTICS_SCOPE, GSCDUMP_WRITE_ANALYTICS_SCOPE, accountNextActions, accountStatuses, analyticsNextActions, analyticsStatuses, hasOptionalIndexingScope, hasRequiredAnalyticsScope, indexingNextActions, indexingStatuses, lifecycleErrorCodes, parseGrantedScopes, propertyNextActions, propertyStatuses, querySourceModes, sitemapNextActions, sitemapStatuses };

package/dist/{_chunks → query}/builder.d.mts

@@ -1,4 +1,4 @@
-import { GscAggregationType, GscDataState, GscSearchAnalyticsRequest, GscSearchType } from "./contracts.mjs";
+import { GscAggregationType, GscDataState, GscSearchAnalyticsRequest, GscSearchType } from "../contracts.mjs";
 import { BuilderState, Column, Dimension, Filter, Metric, MetricColumn } from "./types.mjs";
 type SelectableColumn = Column<Dimension> | MetricColumn<Metric>;
 type OrderableColumn = MetricColumn<Metric> | Column<'date'>;
@@ -21,4 +21,4 @@ interface GSCQueryBuilder<D extends Dimension[] = [], C = object> {
   getState: () => BuilderState;
 }
 declare const gsc: GSCQueryBuilder<[], object>;
-export { GSCQueryBuilder, gsc };
+export { GSCQueryBuilder, OrderableColumn, SelectableColumn, gsc };

package/dist/query/builder.mjs

@@ -0,0 +1,86 @@
+import { resolveToBody } from "./resolver.mjs";
+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(...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,
+				metrics: metrics.length > 0 ? metrics : void 0
+			});
+		},
+		where(filter) {
+			return createBuilder({
+				...state,
+				filter
+			});
+		},
+		prefilter(filter) {
+			return createBuilder({
+				...state,
+				prefilter: filter
+			});
+		},
+		orderBy(col, dir) {
+			const column = isMetricColumn(col) ? col.metric : col.dimension;
+			return createBuilder({
+				...state,
+				orderBy: {
+					column,
+					dir
+				}
+			});
+		},
+		limit(n) {
+			return createBuilder({
+				...state,
+				rowLimit: n
+			});
+		},
+		offset(n) {
+			return createBuilder({
+				...state,
+				startRow: n
+			});
+		},
+		dataState(s) {
+			return createBuilder({
+				...state,
+				dataState: s
+			});
+		},
+		aggregationType(t) {
+			return createBuilder({
+				...state,
+				aggregationType: t
+			});
+		},
+		type(t) {
+			return createBuilder({
+				...state,
+				searchType: t
+			});
+		},
+		toBody() {
+			return resolveToBody(state);
+		},
+		getState() {
+			return { ...state };
+		}
+	};
+}
+const gsc = createBuilder({ dimensions: [] });
+export { gsc };

package/dist/query/columns.d.mts

@@ -0,0 +1,15 @@
+import { Column, MetricColumn, QueryParam } from "./types.mjs";
+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 hour: Column<"hour">;
+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">;
+export { clicks, country, ctr, date, device, hour, impressions, page, position, query, queryCanonical, searchAppearance, searchType };

package/dist/query/columns.mjs

@@ -0,0 +1,23 @@
+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 hour = createColumn("hour");
+const clicks = createMetricColumn("clicks");
+const impressions = createMetricColumn("impressions");
+const ctr = createMetricColumn("ctr");
+const position = createMetricColumn("position");
+const searchType = createQueryParam("searchType");
+export { clicks, country, ctr, date, device, hour, impressions, page, position, query, queryCanonical, searchAppearance, searchType };

package/dist/query/constants.d.mts

@@ -0,0 +1,19 @@
+import _default from "./utils/countries.mjs";
+declare const Devices: {
+  readonly MOBILE: 'MOBILE';
+  readonly DESKTOP: 'DESKTOP';
+  readonly TABLET: 'TABLET';
+};
+type Device = typeof Devices[keyof typeof Devices];
+declare const SearchTypes: {
+  readonly WEB: 'web';
+  readonly IMAGE: 'image';
+  readonly VIDEO: 'video';
+  readonly NEWS: 'news';
+  readonly DISCOVER: 'discover';
+  readonly GOOGLE_NEWS: 'googleNews';
+};
+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];
+export { Countries, Country, Device, Devices, SearchType, SearchTypes };

package/dist/query/constants.mjs

@@ -0,0 +1,16 @@
+import countries_default from "./utils/countries.mjs";
+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()]));
+export { Countries, Devices, SearchTypes };

package/dist/query/errors.d.mts

@@ -0,0 +1,85 @@
+import { Dimension } from "./types.mjs";
+type QueryErrorKind = 'missing-date-range' | 'invalid-row-limit' | 'invalid-start-row' | 'invalid-data-state' | 'invalid-aggregation-type' | 'invalid-builder-state' | 'invalid-filter' | 'unsupported-capability' | 'unresolvable-dataset';
+type QueryError = {
+  kind: 'missing-date-range';
+  message: string;
+} | {
+  kind: 'invalid-row-limit';
+  value: unknown;
+  message: string;
+} | {
+  kind: 'invalid-start-row';
+  value: unknown;
+  message: string;
+} | {
+  kind: 'invalid-data-state';
+  message: string;
+} | {
+  kind: 'invalid-aggregation-type';
+  message: string;
+} | {
+  kind: 'invalid-builder-state';
+  message: string;
+  cause?: unknown;
+} | {
+  kind: 'invalid-filter';
+  message: string;
+} | {
+  kind: 'unsupported-capability';
+  capability: string;
+  context: string;
+  message: string;
+} | {
+  kind: 'unresolvable-dataset';
+  dimensions: readonly Dimension[];
+  filterDims: readonly Dimension[];
+  message: string;
+};
+declare const queryErrors: {
+  readonly missingDateRange: () => QueryError;
+  readonly invalidRowLimit: (value: unknown) => QueryError;
+  readonly invalidStartRow: (value: unknown) => QueryError;
+  readonly hourDimensionRequiresHourlyState: () => QueryError;
+  readonly hourlyStateRequiresHourDimension: () => QueryError;
+  readonly byPropertyUnsupportedSearchType: () => QueryError;
+  readonly byPropertyNotAllowedWithPage: () => QueryError;
+  readonly byNewsShowcaseRequiresSearchType: () => QueryError;
+  readonly byNewsShowcaseNotAllowedWithPage: () => QueryError;
+  readonly byNewsShowcaseRequiresShowcaseFilter: () => QueryError;
+  readonly invalidBuilderState: (cause?: unknown) => QueryError;
+  readonly malformedFilterLeaf: () => QueryError;
+  readonly unsupportedCapability: (capability: string, context: string) => QueryError;
+  readonly unresolvableDataset: (dimensions: readonly Dimension[], filterDims?: readonly Dimension[]) => QueryError;
+};
+declare function isQueryError(value: unknown): value is QueryError;
+/**
+ * Thrown when a query needs a planner capability (regex pushdown, comparison
+ * joins, multi-dataset reads) the target engine lacks. Engines catch it to fall
+ * back to the live GSC API. Carries the typed `queryError` value so a caller can
+ * read the modelled failure instead of parsing the message.
+ */
+declare class UnsupportedLogicalCapabilityError extends Error {
+  readonly queryError: Extract<QueryError, {
+    kind: 'unsupported-capability';
+  }>;
+  constructor(capability: string, context: string);
+}
+/**
+ * Thrown when a query's grouped + filtered dimensions span more than one stored
+ * dataset. Replaces the resolver's raw "unknown column" error so hosts can map
+ * it to a 4xx instead of leaking an opaque 500. Carries the typed `queryError`.
+ */
+declare class UnresolvableDatasetError extends Error {
+  readonly queryError: Extract<QueryError, {
+    kind: 'unresolvable-dataset';
+  }>;
+  constructor(dimensions: readonly Dimension[], filterDims?: readonly Dimension[]);
+}
+/**
+ * Re-raises a `QueryError` value as an `Error`, preserving the historical class
+ * identity for the two errors engines match on by name (`UnresolvableDatasetError`,
+ * `UnsupportedLogicalCapabilityError`). Pairs with `unwrapResult` so a
+ * `fooResult(): Result<A, QueryError>` core can back a throwing `foo()`.
+ */
+declare function queryErrorToException(error: QueryError): Error;
+export { QueryError, QueryErrorKind, UnresolvableDatasetError, UnsupportedLogicalCapabilityError, isQueryError, queryErrorToException, queryErrors };

package/dist/query/errors.mjs

@@ -0,0 +1,141 @@
+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;
+		}
+	}
+}
+export { UnresolvableDatasetError, UnsupportedLogicalCapabilityError, isQueryError, queryErrorToException, queryErrors };

package/dist/query/index.d.mts

@@ -1,78 +1,12 @@
-import { GscSearchAnalyticsRequest } from "../_chunks/contracts.mjs";
-import { Result } from "../_chunks/result.mjs";
-import { currentPstDate } from "../_chunks/dayjs.mjs";
-import { BuilderState, Column, Countries, Country, Device, Devices, Dimension, DimensionValueMap, Filter, FilterInput, GSCResult, GSCRow, InternalFilter, JsonFilter, JsonInternalFilter, MergeConstraints, Metric, MetricColumn, QueryParam, QueryParamName, QueryParamValueMap, SearchType, SearchTypes } from "../_chunks/types.mjs";
-import { GSCQueryBuilder, gsc } from "../_chunks/builder.mjs";
-import { ComparisonFilter, LogicalComparisonPlan, LogicalDataset, LogicalDimensionFilter, LogicalMetricFilter, LogicalQueryPlan, PlannerCapabilities, QueryError, QueryErrorKind, UnresolvableDatasetError, UnsupportedLogicalCapabilityError, buildLogicalComparisonPlan, buildLogicalComparisonPlanResult, buildLogicalPlan, buildLogicalPlanResult, isQueryError, queryErrorToException, queryErrors } from "../_chunks/plan.mjs";
-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 hour: Column<"hour">;
-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">;
-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>;
-declare function like<D extends Dimension>(column: Column<D>, pattern: string): Filter<object>;
-declare function regex<D extends Dimension>(column: Column<D>, pattern: RegExp | string): Filter<object>;
-declare function notRegex<D extends Dimension>(column: Column<D>, pattern: RegExp | string): Filter<object>;
-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(column: Column<'date'>, value: string): Filter<object>;
-declare function gt<M extends Metric>(column: MetricColumn<M>, value: number): Filter<object>;
-declare function gt(column: Column<'date'>, value: string): Filter<object>;
-declare function lte<M extends Metric>(column: MetricColumn<M>, value: number): Filter<object>;
-declare function lte(column: Column<'date'>, value: string): Filter<object>;
-declare function lt<M extends Metric>(column: MetricColumn<M>, value: number): Filter<object>;
-declare function lt(column: Column<'date'>, value: string): Filter<object>;
-declare function between<M extends Metric>(column: MetricColumn<M>, start: number, end: number): Filter<object>;
-declare function between(column: Column<'date'>, start: string, end: string): Filter<object>;
-declare function topLevel(column: Column<'page'>): Filter<object>;
-declare function normalizeFilter(input?: FilterInput): Filter<any> | undefined;
-/**
- * Errors-as-values core for {@link normalizeBuilderState}: returns an
- * `invalid-builder-state` `QueryError` when the untrusted partner-API body is
- * not an object, and an `invalid-filter` `QueryError` when a filter leaf lacks
- * its string `dimension`/`operator`, instead of throwing. Also coerces
- * alternative `orderBy` shapes into the canonical `{ column, dir }`.
- * Receive-edge parse (parse, don't validate), so hosts can map a bad body to a
- * 4xx and downstream consumers only ever see the canonical shape.
- */
-declare function normalizeBuilderStateResult(state: unknown): Result<BuilderState, QueryError>;
-declare function normalizeBuilderState(state: unknown): BuilderState;
-declare function extractDateRange(input?: FilterInput): {
-  startDate?: string;
-  endDate?: string;
-};
-declare function extractMetricFilters(input?: FilterInput): InternalFilter[];
-declare function extractSpecialOperatorFilters(input?: FilterInput): InternalFilter[];
-/**
- * Pull `searchType` out of a BuilderState filter. Returns undefined for
- * missing/invalid shapes — callers treat that as "no scope" (cross-type read).
- * Validated against the canonical `SearchTypes` set so unknown strings
- * don't reach the engine.
- */
-declare function extractSearchType(state: BuilderState | undefined | null): SearchType | undefined;
-/**
- * Errors-as-values core: turns a `BuilderState` into a GSC API request body or
- * returns a typed `QueryError` for every modelled bad-query case (missing date
- * range, out-of-range row limit / start row, hour/dataState mismatch, illegal
- * aggregationType combination). `resolveToBody` is the throwing wrapper over this
- * for `.toBody()` and the live-API client paths.
- */
-declare function resolveToBodyResult(state: BuilderState): Result<GscSearchAnalyticsRequest, QueryError>;
-declare function resolveToBody(state: BuilderState): GscSearchAnalyticsRequest;
+import { currentPstDate } from "./utils/dayjs.mjs";
+import { Countries, Country, Device, Devices, SearchType, SearchTypes } from "./constants.mjs";
+import { BuilderState, Column, Dimension, DimensionValueMap, Filter, FilterInput, GSCResult, GSCRow, InternalFilter, JsonFilter, JsonInternalFilter, Metric, MetricColumn, QueryParam, QueryParamName, QueryParamValueMap } from "./types.mjs";
+import { GSCQueryBuilder, gsc } from "./builder.mjs";
+import { clicks, country, ctr, date, device, hour, impressions, page, position, query, queryCanonical, searchAppearance, searchType } from "./columns.mjs";
+import { QueryError, QueryErrorKind, UnresolvableDatasetError, UnsupportedLogicalCapabilityError, isQueryError, queryErrorToException, queryErrors } from "./errors.mjs";
+import { and, between, contains, eq, gt, gte, inArray, like, lt, lte, ne, not, notRegex, or, regex, topLevel } from "./operators.mjs";
+import { ComparisonFilter, LogicalComparisonPlan, LogicalDataset, LogicalDimensionFilter, LogicalMetricFilter, LogicalQueryPlan, PlannerCapabilities, buildLogicalComparisonPlan, buildLogicalComparisonPlanResult, buildLogicalPlan, buildLogicalPlanResult } from "./plan.mjs";
+import { extractDateRange, extractMetricFilters, extractSearchType, extractSpecialOperatorFilters, normalizeBuilderState, normalizeBuilderStateResult, normalizeFilter, resolveToBody, resolveToBodyResult } from "./resolver.mjs";
 declare function today(): string;
 declare function daysAgo(n: number): string;
 export { type BuilderState, type Column, type ComparisonFilter, Countries, type Country, type Device, Devices, type Dimension, type DimensionValueMap, type Filter, type FilterInput, type GSCQueryBuilder, type GSCResult, type GSCRow, type InternalFilter, type JsonFilter, type JsonInternalFilter, type LogicalComparisonPlan, type LogicalDataset, type LogicalDimensionFilter, type LogicalMetricFilter, type LogicalQueryPlan, type Metric, type MetricColumn, type PlannerCapabilities, QueryError, QueryErrorKind, type QueryParam, type QueryParamName, type QueryParamValueMap, type SearchType, SearchTypes, UnresolvableDatasetError, UnsupportedLogicalCapabilityError, and, between, buildLogicalComparisonPlan, buildLogicalComparisonPlanResult, buildLogicalPlan, buildLogicalPlanResult, clicks, contains, country, ctr, currentPstDate, date, daysAgo, device, eq, extractDateRange, extractMetricFilters, extractSearchType, extractSpecialOperatorFilters, gsc, gt, gte, hour, impressions, inArray, isQueryError, like, lt, lte, ne, normalizeBuilderState, normalizeBuilderStateResult, normalizeFilter, not, notRegex, or, page, position, query, queryCanonical, queryErrorToException, queryErrors, regex, resolveToBody, resolveToBodyResult, searchAppearance, searchType, today, topLevel };