@gscdump/sdk 0.40.2 → 1.0.0

package/dist/index.d.mts

@@ -1,11 +1,32 @@
-import { __exportAll, __reExport, query_d_exports } from "./_chunks/query.mjs";
 import { Result } from "gscdump/result";
-import { arbitrarySql as arbitrarySql$1, auxCloudOnly as auxCloudOnly$1, entityDailySparkline as entityDailySparkline$1, entityDailyTimeseries as entityDailyTimeseries$1, multiSeriesStackedDaily as multiSeriesStackedDaily$1, singleRowLookup as singleRowLookup$1, siteDailyTimeseries as siteDailyTimeseries$1, topNBreakdown as topNBreakdown$1, twoDimensionDetail as twoDimensionDetail$1 } from "@gscdump/contracts/archetypes";
-import { AddPartnerTeamMemberParams, AnalyticsClient, AnalyticsClient as AnalyticsClient$1, BackfillRange, BackfillResponse, BindPartnerSiteTeamParams, BuilderState, BulkRegisterPartnerSiteResult, BulkRegisterPartnerSitesParams, BulkRegisterPartnerSitesResponse, CANONICAL_WEBHOOK_EVENTS, CanonicalWebhookEventType, CreatePartnerTeamParams, CreateWebhookEnvelopeOptions, DataDetailOptions, DataQueryOptions, DeletePartnerUserResponse, GscComparisonFilter, GscdumpAnalysisParams, GscdumpAnalysisPreset, GscdumpAnalysisResponse, GscdumpAnalysisSourcesResponse, GscdumpAvailableSite, GscdumpCanonicalMismatchesResponse, GscdumpDataDetailResponse, GscdumpDataResponse, GscdumpDataRow, GscdumpDateRangeParams, GscdumpIndexPercentResponse, GscdumpIndexingDiagnosticsResponse, GscdumpIndexingResponse, GscdumpIndexingUrlStatus, GscdumpIndexingUrlsResponse, GscdumpKeywordSparklinesParams, GscdumpKeywordSparklinesResponse, GscdumpMeta, GscdumpPageTrendParams, GscdumpPageTrendResponse, GscdumpPermissionRecovery, GscdumpQueryTrendParams, GscdumpQueryTrendResponse, GscdumpSiteRegistration, GscdumpSitemap, GscdumpSitemapChangesResponse, GscdumpSitemapHistory, GscdumpSitemapsResponse, GscdumpSyncStatusResponse, GscdumpSyncStatusResponse as GscdumpSyncStatusResponse$1, GscdumpTeamMemberRow, GscdumpTeamRow, GscdumpTopAssociationParams, GscdumpTopAssociationResponse, GscdumpTotals, GscdumpUserRegistration, GscdumpUserSettings, GscdumpUserSite, GscdumpUserSite as GscdumpUserSite$1, GscdumpUserStatus, GscdumpUserTokenUpdate, IndexingDiagnosticsParams, IndexingUrlsParams, InspectionHistoryResponse, InspectionIndex, PartnerClient, PartnerClient as PartnerClient$1, PartnerLifecycleAccount, PartnerLifecycleResponse, PartnerLifecycleSite, PartnerLifecycleSite as PartnerLifecycleSite$1, PartnerWebhookData, PartnerWebhookHeaders, PartnerWebhookHeaders as PartnerWebhookHeaders$1, RegisterPartnerSiteParams, RegisterPartnerUserParams, RollupEnvelope, SourceInfoOptions, UpdatePartnerUserTokensParams, VALID_WEBHOOK_EVENTS, WEBHOOK_CONTRACT_VERSION, WEBHOOK_CONTRACT_VERSION_HEADER, WEBHOOK_DELIVERY_HEADER, WEBHOOK_EVENT_HEADER, WEBHOOK_SIGNATURE_HEADER, WEBHOOK_TIMESTAMP_HEADER, WebhookEnvelope, WebhookEnvelope as WebhookEnvelope$1, WebhookEventType, WhoamiResponse } from "@gscdump/contracts";
+import { BuilderState } from "gscdump/query";
+import { AddPartnerTeamMemberParams, AnalysisSourcesResponse, ArchetypeQuery, BackfillRange, BackfillResponse, BindPartnerSiteTeamParams, BindPartnerTeamCatalogParams, BindPartnerTeamCatalogResponse, BuilderStateWire, BulkFileResolutionRequest, BulkFileResolutionResponse, BulkRegisterPartnerSitesParams, BulkRegisterPartnerSitesResponse, CANONICAL_WEBHOOK_EVENTS, CountriesResponse, CreatePartnerTeamParams, DataDetailOptions, DataQueryOptions, DeletePartnerUserResponse, GscAddAndVerifyResponse, GscSearchType, GscVerificationRequest, GscVerificationTokenResponse, GscdumpAnalysisSourcesResponse, GscdumpAvailableSite, GscdumpCanonicalMismatchesResponse, GscdumpDataDetailResponse, GscdumpDataResponse, GscdumpIndexPercentResponse, GscdumpIndexingDiagnosticsResponse, GscdumpIndexingResponse, GscdumpIndexingUrlsResponse, GscdumpKeywordSparklinesParams, GscdumpKeywordSparklinesResponse, GscdumpPageTrendParams, GscdumpPageTrendResponse, GscdumpPermissionRecovery, GscdumpQueryTrendParams, GscdumpQueryTrendResponse, GscdumpSiteIntIdCrosswalkResponse, GscdumpSiteRegistration, GscdumpSitemapChangesResponse, GscdumpSitemapMembershipParams, GscdumpSitemapMembershipResponse, GscdumpSitemapsResponse, GscdumpSyncStatusResponse, GscdumpTeamCatalogRef, GscdumpTeamMemberRow, GscdumpTeamRow, GscdumpTopAssociationParams, GscdumpTopAssociationResponse, GscdumpUserRegistration, GscdumpUserSettings, GscdumpUserSite, GscdumpUserStatus, GscdumpUserTokenUpdate, IndexingDiagnostics, IndexingDiagnosticsParams, IndexingInspectRateLimited, IndexingInspectRequest, IndexingInspectResponse, IndexingUrlStatus, IndexingUrlsParams, IndexingUrlsResponse, InspectionHistoryResponse, InspectionIndex, PartnerLifecycleResponse, PartnerLifecycleSite, PartnerSitemapAction, PartnerSitemapActionResponse, PartnerWebhookHeaders, QueryDimSourceResponse, RegisterPartnerSiteParams, RegisterPartnerUserParams, RollupEnvelope, SearchAppearanceResponse, SiteListItem, SitemapChangesResponse, SitemapHistoryResponse, SitemapIndex, SourceInfoOptions, SourceInfoResponse, UpdatePartnerUserTokensParams, VALID_WEBHOOK_EVENTS, WEBHOOK_CONTRACT_VERSION, WEBHOOK_CONTRACT_VERSION_HEADER, WEBHOOK_DELIVERY_HEADER, WEBHOOK_EVENT_HEADER, WEBHOOK_SIGNATURE_HEADER, WEBHOOK_TIMESTAMP_HEADER, WebhookEnvelope, WhoamiResponse, WireDateRange } from "@gscdump/contracts";
 import { ZodTypeAny } from "zod";
 import { ActionSource } from "@gscdump/analysis";
 import { AnalysisTool } from "@gscdump/engine/analysis-types";
-export * from "@gscdump/contracts";
+type GscSearchType$1 = 'web' | 'image' | 'video' | 'news' | 'discover' | 'googleNews';
+interface SearchTypeOptions {
+  searchType?: GscSearchType$1;
+}
+interface SourceRangeOptions {
+  start?: string;
+  end?: string;
+  startDate?: string;
+  endDate?: string;
+}
+interface AnalysisSourcesOptions extends SearchTypeOptions, SourceRangeOptions {
+  tables?: string[] | string;
+  maxBytes?: number;
+  maxRows?: number;
+  maxFiles?: number;
+}
+declare const DEFAULT_SEARCH_TYPE: GscSearchType$1;
+declare function withDefaultSearchType<T extends object>(value: T, searchType?: GscSearchType$1): T & SearchTypeOptions & Record<string, unknown>;
+declare function withDefaultSearchType<T>(value: T, searchType?: GscSearchType$1): T;
+declare function searchTypeQuery(searchType?: GscSearchType$1): Record<string, string>;
+declare function dateRangeOptionsQuery(options: SourceRangeOptions | undefined): Record<string, string>;
+declare function sourceInfoQuery(options: SourceInfoOptions | undefined): Record<string, string>;
+declare function tablesQuery(tablesOrOptions: string[] | string | AnalysisSourcesOptions | undefined, options?: AnalysisSourcesOptions): Record<string, string>;
 type PartnerErrorKind = 'auth' | 'rate-limit' | 'provisioning' | 'permission' | 'network' | 'validation' | 'not-found' | 'server' | 'unknown';
 interface PartnerErrorInfo {
   kind: PartnerErrorKind;
@@ -20,10 +41,6 @@ declare class PartnerApiError extends Error {
   constructor(info: PartnerErrorInfo);
 }
 declare function toPartnerError(error: unknown): PartnerApiError;
-/** Narrow an unknown error to the modelled `PartnerApiError`. */
-declare function isPartnerError(error: unknown): error is PartnerApiError;
-/** Human-readable, log-friendly rendering of a modelled partner failure. */
-declare function formatPartnerError(error: PartnerApiError): string;
 /**
  * Re-raise a modelled `PartnerApiError` as itself. The error variant of every
  * `*Result` core already IS the throwable `PartnerApiError`, so the throwing
@@ -61,7 +78,46 @@ interface AnalyticsClientOptions extends HostedClientOptions {
   headers?: AnalyticsHeaders;
   validate?: boolean | 'request' | 'response';
 }
-declare function createAnalyticsClient(options?: AnalyticsClientOptions): AnalyticsClient$1;
+/** Hosted analytics transport exposed by `@gscdump/sdk`. */
+interface AnalyticsClient {
+  whoami: () => Promise<WhoamiResponse>;
+  listSites: () => Promise<SiteListItem[]>;
+  getBulkSources: (params: BulkFileResolutionRequest) => Promise<BulkFileResolutionResponse>;
+  getSourceInfo: (siteId: string, options?: SourceInfoOptions) => Promise<SourceInfoResponse>;
+  getAnalysisSources: (siteId: string, tables?: string[] | string | AnalysisSourcesOptions, options?: SearchTypeOptions & SourceRangeOptions) => Promise<AnalysisSourcesResponse>;
+  getQueryDimSource: (siteId: string) => Promise<QueryDimSourceResponse>;
+  analyze: <T = unknown>(siteId: string, params: unknown) => Promise<T>;
+  getRollup: <T = unknown>(siteId: string, rollupId: string, params?: {
+    start?: string;
+    end?: string;
+  }) => Promise<RollupEnvelope<T>>;
+  requestBackfill: (siteId: string, range: BackfillRange) => Promise<BackfillResponse>;
+  getSitemaps: (siteId: string) => Promise<SitemapIndex>;
+  getSitemapHistory: (siteId: string, hash: string) => Promise<SitemapHistoryResponse>;
+  getSitemapChanges: (siteId: string, params?: {
+    days?: number;
+  }) => Promise<SitemapChangesResponse>;
+  getInspections: (siteId: string) => Promise<InspectionIndex>;
+  getInspectionHistory: (siteId: string, hash: string) => Promise<InspectionHistoryResponse>;
+  getIndexingUrls: (siteId: string, params?: {
+    limit?: number;
+    offset?: number;
+    status?: IndexingUrlStatus;
+    issue?: string;
+    search?: string;
+  }) => Promise<IndexingUrlsResponse>;
+  getIndexingDiagnostics: (siteId: string, params?: IndexingDiagnosticsParams) => Promise<IndexingDiagnostics>;
+  requestIndexingInspect: (siteId: string, body: IndexingInspectRequest) => Promise<IndexingInspectResponse | IndexingInspectRateLimited>;
+  getCountries: (siteId: string, range: {
+    start: string;
+    end: string;
+  }) => Promise<CountriesResponse>;
+  getSearchAppearance: (siteId: string, range: {
+    start: string;
+    end: string;
+  }) => Promise<SearchAppearanceResponse>;
+}
+declare function createAnalyticsClient(options?: AnalyticsClientOptions): AnalyticsClient;
 type GscAnalyzerKind = 'analyzer' | 'semantic' | 'action';
 type GscAnalyzerAccent = 'primary' | 'warning' | 'success' | 'error' | 'neutral';
 interface GscAnalyzerInsightCard {
@@ -137,20 +193,51 @@ interface DailyAnonInput {
   anonymizedImpressionsPct: number;
 }
 declare function weightedAnonPct(days: readonly DailyAnonInput[] | null | undefined, window?: number): number | null;
-declare namespace archetypes_d_exports {
-  export { ARCHETYPE_EXECUTION_CLASS, arbitrarySql, auxCloudOnly, entityDailySparkline, entityDailyTimeseries, multiSeriesStackedDaily, singleRowLookup, siteDailyTimeseries, topNBreakdown, twoDimensionDetail };
-}
-import * as import__gscdump_contracts_archetypes from "@gscdump/contracts/archetypes";
-declare const ARCHETYPE_EXECUTION_CLASS: Record<import("@gscdump/contracts").QueryArchetype, import("@gscdump/contracts").ArchetypeExecutionClass>;
-declare const arbitrarySql: typeof arbitrarySql$1;
-declare const auxCloudOnly: typeof auxCloudOnly$1;
-declare const entityDailySparkline: typeof entityDailySparkline$1;
-declare const entityDailyTimeseries: typeof entityDailyTimeseries$1;
-declare const multiSeriesStackedDaily: typeof multiSeriesStackedDaily$1;
-declare const singleRowLookup: typeof singleRowLookup$1;
-declare const siteDailyTimeseries: typeof siteDailyTimeseries$1;
-declare const topNBreakdown: typeof topNBreakdown$1;
-declare const twoDimensionDetail: typeof twoDimensionDetail$1;
+/**
+ * Extract the `{ start, end }` date window from a builder-state filter in
+ * either accepted format (SDK-branded or partner wire). Returns `null` when no
+ * complete range is present.
+ */
+declare function extractWireDateRange(filter: unknown): WireDateRange | null;
+interface BuilderStateToArchetypeOptions {
+  searchType?: GscSearchType;
+  compareRange?: WireDateRange;
+}
+/**
+ * Translate a `BuilderState` into the best-fit `ArchetypeQuery`, or `null`
+ * when the shape can't be expressed (the caller keeps its legacy path — this
+ * function never throws).
+ *
+ * Supported shapes (5 of the archetypes — the others are either caller-driven
+ * builders never reached via a BuilderState, `arbitrary-sql`, or
+ * `aux-cloud-only`):
+ *  - `dimensions: ['date']`, no entity filter                → site-daily-timeseries
+ *  - `dimensions: ['date']`, one page/query/queryCanonical
+ *    equality                                                → entity-daily-timeseries
+ *  - `dimensions: ['date', X]`                               → multi-series-stacked-daily
+ *  - `dimensions: [X]` (non-date)                            → top-n-breakdown (extra
+ *    equality filters on OTHER dimensions become `facets`)
+ *  - `dimensions: ['page','query']` (either order)           → two-dimension-detail
+ *
+ * Everything else — 0 or 3+ dimensions, no date range, an OR group, a
+ * non-equality predicate the target SQL builder can't apply, a
+ * `two-dimension-detail` pair that isn't exactly {page, query} (the SQL is
+ * hardcoded to `url, query` regardless of which two dims were requested) —
+ * returns `null`.
+ */
+declare function builderStateToArchetype(siteId: string, state: BuilderState, opts?: BuilderStateToArchetypeOptions): ArchetypeQuery | null;
+/**
+ * Archetypes a hosted seam's execution wrapper can safely serve end-to-end
+ * today (rows + an ACCURATE `totalCount`/`totals`, matching the legacy
+ * `R2QueryResult` contract). `builderStateToArchetype` above can produce a
+ * `two-dimension-detail` query, but `TwoDimensionDetailQuery`/
+ * `buildTwoDimensionDetail` support neither `offset` nor `includeTotal` —
+ * there is no way to get an exact grand total or paginate past page 1 through
+ * the dispatcher yet, so seam wrappers decline it (same as a compile miss)
+ * rather than serve a wrong `totalCount`. Revisit once the contract grows
+ * those fields.
+ */
+declare function archetypeSeamSupportsQuery(query: ArchetypeQuery): boolean;
 type PartnerFetch = HostedFetch;
 type PartnerHeaders = HostedHeaders;
 type PartnerFetchOptions = HostedFetchOptions;
@@ -169,8 +256,106 @@ interface PartnerClientOptions extends HostedClientOptions {
   /** Validate request payloads and response bodies with exported Zod schemas. */
   validate?: boolean | 'request' | 'response';
 }
-declare function createPartnerClient(options?: PartnerClientOptions): PartnerClient$1;
-declare const COUNTRY_NAMES: Record<string, string>;
+/** Hosted partner transport exposed by `@gscdump/sdk`. */
+interface PartnerClient {
+  registerUser: (params: RegisterPartnerUserParams) => Promise<GscdumpUserRegistration>;
+  updateUserTokens: (userId: string, params: UpdatePartnerUserTokensParams) => Promise<GscdumpUserTokenUpdate>;
+  getUserStatus: (userId: string) => Promise<GscdumpUserStatus>;
+  getUserLifecycle: (userId: string) => Promise<PartnerLifecycleResponse>;
+  waitForUserReady: (userId: string, options?: {
+    attempts?: number;
+    intervalMs?: number;
+  }) => Promise<GscdumpUserStatus>;
+  waitForUserLifecycleReady: (userId: string, options?: {
+    attempts?: number;
+    intervalMs?: number;
+  }) => Promise<PartnerLifecycleResponse>;
+  getUserSites: (userId: string) => Promise<{
+    sites: GscdumpUserSite[];
+  }>;
+  getAvailableSites: (userId: string) => Promise<{
+    sites: GscdumpAvailableSite[];
+  }>;
+  getUserSiteIntIdCrosswalk: (userId: string) => Promise<GscdumpSiteIntIdCrosswalkResponse>;
+  registerSite: (params: RegisterPartnerSiteParams) => Promise<GscdumpSiteRegistration>;
+  bulkRegisterSites: (params: BulkRegisterPartnerSitesParams) => Promise<BulkRegisterPartnerSitesResponse>;
+  requestSiteVerificationToken: (params: GscVerificationRequest) => Promise<GscVerificationTokenResponse>;
+  addAndVerifySite: (params: GscVerificationRequest) => Promise<GscAddAndVerifyResponse>;
+  deleteUser: (userId: string) => Promise<DeletePartnerUserResponse>;
+  deleteSite: (siteId: string) => Promise<{
+    success: boolean;
+  }>;
+  getAnalysisSources: (siteId: string, tables?: string[] | string | AnalysisSourcesOptions, options?: SearchTypeOptions & SourceRangeOptions) => Promise<GscdumpAnalysisSourcesResponse>;
+  getSiteSyncStatus: (siteId: string, userId?: string) => Promise<GscdumpSyncStatusResponse>;
+  getData: (siteId: string, state: BuilderStateWire, options?: DataQueryOptions) => Promise<GscdumpDataResponse>;
+  getDataDetail: (siteId: string, state: BuilderStateWire, options?: DataDetailOptions) => Promise<GscdumpDataDetailResponse>;
+  getSitemaps: (siteId: string) => Promise<GscdumpSitemapsResponse>;
+  getSitemapChanges: (siteId: string, days?: number) => Promise<GscdumpSitemapChangesResponse>;
+  getSitemapMembership: (siteId: string, params: GscdumpSitemapMembershipParams) => Promise<GscdumpSitemapMembershipResponse>;
+  postSitemapAction: (siteId: string, action: PartnerSitemapAction) => Promise<PartnerSitemapActionResponse>;
+  submitSitemap: (siteId: string, sitemapUrl: string, action?: 'submit' | 'delete') => Promise<Extract<PartnerSitemapActionResponse, {
+    action: 'submitted' | 'deleted';
+  }>>;
+  refreshSitemaps: (siteId: string) => Promise<Extract<PartnerSitemapActionResponse, {
+    action: 'refreshed';
+  }>>;
+  autoDiscoverSitemap: (siteId: string) => Promise<Extract<PartnerSitemapActionResponse, {
+    action: 'auto-discover';
+  }>>;
+  getIndexing: (siteId: string, days?: number) => Promise<GscdumpIndexingResponse>;
+  getIndexingUrls: (siteId: string, params?: IndexingUrlsParams) => Promise<GscdumpIndexingUrlsResponse>;
+  getIndexingDiagnostics: (siteId: string, params?: IndexingDiagnosticsParams) => Promise<GscdumpIndexingDiagnosticsResponse>;
+  requestIndexingInspect: (siteId: string, body: IndexingInspectRequest) => Promise<IndexingInspectResponse | IndexingInspectRateLimited>;
+  getUserSettings: () => Promise<GscdumpUserSettings>;
+  patchUserSettings: (body: Partial<GscdumpUserSettings>) => Promise<GscdumpUserSettings>;
+  recoverPermission: (siteId: string) => Promise<GscdumpPermissionRecovery>;
+  getTopAssociation: (siteId: string, params: GscdumpTopAssociationParams) => Promise<GscdumpTopAssociationResponse>;
+  getKeywordSparklines: (siteId: string, params: GscdumpKeywordSparklinesParams) => Promise<GscdumpKeywordSparklinesResponse>;
+  getQueryTrend: (siteId: string, params: GscdumpQueryTrendParams) => Promise<GscdumpQueryTrendResponse>;
+  getPageTrend: (siteId: string, params: GscdumpPageTrendParams) => Promise<GscdumpPageTrendResponse>;
+  getCanonicalMismatches: (siteId: string) => Promise<GscdumpCanonicalMismatchesResponse>;
+  getIndexPercent: (siteId: string, params?: {
+    invisibleLimit?: number;
+    invisibleOffset?: number;
+    orphanLimit?: number;
+  }) => Promise<GscdumpIndexPercentResponse>;
+  createTeam: (params: CreatePartnerTeamParams) => Promise<{
+    team: GscdumpTeamRow;
+  }>;
+  renameTeam: (teamId: string, params: {
+    name: string;
+  }) => Promise<{
+    ok: true;
+    name: string;
+  }>;
+  deleteTeam: (teamId: string) => Promise<{
+    ok: true;
+  }>;
+  listTeamMembers: (teamId: string) => Promise<{
+    members: GscdumpTeamMemberRow[];
+  }>;
+  addTeamMember: (teamId: string, params: AddPartnerTeamMemberParams) => Promise<{
+    ok: true;
+    role: string;
+    alreadyExisted?: boolean;
+  }>;
+  updateTeamMemberRole: (teamId: string, userId: string, params: {
+    role: GscdumpTeamMemberRow['role'];
+  }) => Promise<{
+    ok: true;
+    role: string;
+  }>;
+  removeTeamMember: (teamId: string, userId: string) => Promise<{
+    ok: true;
+  }>;
+  bindSiteToTeam: (userId: string, siteId: string, params: BindPartnerSiteTeamParams) => Promise<{
+    ok: true;
+    teamId: string | null;
+  }>;
+  getTeamCatalog: (teamId: string) => Promise<GscdumpTeamCatalogRef>;
+  bindTeamCatalog: (teamId: string, params: BindPartnerTeamCatalogParams) => Promise<BindPartnerTeamCatalogResponse>;
+}
+declare function createPartnerClient(options?: PartnerClientOptions): PartnerClient;
 declare const countryName: (code: string) => string;
 declare const CWV_GOOD_LCP = 2500;
 declare const CWV_POOR_LCP = 4000;
@@ -184,14 +369,6 @@ declare function cwvBucket(metric: 'lcp' | 'inp' | 'cls', v: number): CwvBucket;
 declare function truncateQuery(q: string, max?: number): string;
 /** Best-effort extract a hostname; returns undefined if the URL is unparseable. */
 declare function siteUrlToHostname(url: string | undefined | null): string | undefined;
-/**
- * Split a title with `"quoted"` segments into highlight runs for inline
- * emphasis (e.g. opportunity cards rendering keywords in a stronger weight).
- */
-declare function splitOpportunityTitle(title: string): Array<{
-  text: string;
-  highlight: boolean;
-}>;
 interface GscConsoleUrlOpts {
   /** The GSC property — either `sc-domain:example.com` or a URL-prefix. */
   siteLabel: string;
@@ -230,16 +407,6 @@ interface GscClassifiedError {
   retryAfter?: number;
 }
 declare function classifyGscError(e: unknown): GscClassifiedError;
-/**
- * Partner-API BETWEEN filter on the `date` column — the ubiquitous date
- * window every query carries.
- */
-declare function dateFilter(r: {
-  start: string;
-  end: string;
-}): query_d_exports.Filter<any>;
-/** Partner-API AND combinator — wraps filters in the wire-format `and` group. */
-declare function andFilter(...filters: unknown[]): query_d_exports.Filter<any>;
 type RollingPeriod = '7d' | '28d' | '3m' | '6m' | '12m';
 type CalendarPeriod = 'this-week' | 'this-month' | 'last-month' | 'this-quarter' | 'this-year';
 /**
@@ -370,29 +537,6 @@ declare function positionFor(r: {
   impressions: number;
   sum_position: number;
 }): number;
-type GscSearchType = 'web' | 'image' | 'video' | 'news' | 'discover' | 'googleNews';
-interface SearchTypeOptions {
-  searchType?: GscSearchType;
-}
-interface SourceRangeOptions {
-  start?: string;
-  end?: string;
-  startDate?: string;
-  endDate?: string;
-}
-interface AnalysisSourcesOptions extends SearchTypeOptions, SourceRangeOptions {
-  tables?: string[] | string;
-  maxBytes?: number;
-  maxRows?: number;
-  maxFiles?: number;
-}
-declare const DEFAULT_SEARCH_TYPE: GscSearchType;
-declare function withDefaultSearchType<T extends object>(value: T, searchType?: GscSearchType): T & SearchTypeOptions;
-declare function withDefaultSearchType<T>(value: T, searchType?: GscSearchType): T;
-declare function searchTypeQuery(searchType?: GscSearchType): Record<string, string>;
-declare function dateRangeOptionsQuery(options: SourceRangeOptions | undefined): Record<string, string>;
-declare function sourceInfoQuery(options: SourceInfoOptions | undefined): Record<string, string>;
-declare function tablesQuery(tablesOrOptions: string[] | string | AnalysisSourcesOptions | undefined, options?: AnalysisSourcesOptions): Record<string, string>;
 interface IndexingIssueDetail {
   description: string;
   fix: string;
@@ -405,28 +549,7 @@ interface IndexingIssue {
   count: number;
 }
 declare const issueDetails: Record<string, IndexingIssueDetail>;
-/**
- * Nuxt-SEO-specific fix supplements. Activated by `enrichIssueDetails` when the
- * caller passes a module list that includes the relevant Nuxt module.
- */
-declare const nuxtSeoTips: Record<string, {
-  modules: string[];
-  tip: string;
-}>;
 declare const severityOrder: IssueSeverity[];
-declare const investigationStatusConfig: Record<string, {
-  label: string;
-  icon: string;
-  color: 'success' | 'info' | 'warning' | 'neutral' | 'error';
-}>;
-declare const coverageLabels: Record<string, {
-  short: string;
-  color: string;
-}>;
-declare function coverageLabel(state: string): {
-  short: string;
-  color: string;
-};
 interface IssueGroup {
   id: string;
   label: string;
@@ -442,20 +565,15 @@ interface IssueGroup {
   issueTypes: string[];
 }
 declare const issueGroups: IssueGroup[];
-/** Map from issue type to its group id */
-declare const issueTypeToGroup: Record<string, string>;
-declare function enrichIssueDetails(modules?: {
-  name: string;
-}[]): Record<string, IndexingIssueDetail>;
 /**
  * Stable lifecycle fields shared by the legacy partner response and public v1.
  * Keeping the adapters structural lets consumers migrate to v1 without
  * re-introducing legacy-only fields such as `intId` or `lifecycleRevision`.
  */
-type LifecycleSiteLike = Pick<PartnerLifecycleSite$1, 'siteId' | 'externalSiteId' | 'requestedUrl' | 'gscPropertyUrl' | 'permissionLevel' | 'analytics' | 'indexing' | 'latestError' | 'updatedAt'>;
-declare function analyticsStatusToSyncStatus(status: LifecycleSiteLike['analytics']['status']): GscdumpUserSite$1['syncStatus'];
-declare function lifecycleSiteToUserSite(site: LifecycleSiteLike): GscdumpUserSite$1;
-declare function lifecycleSiteToSyncStatus(site: LifecycleSiteLike): GscdumpSyncStatusResponse$1;
+type LifecycleSiteLike = Pick<PartnerLifecycleSite, 'siteId' | 'externalSiteId' | 'requestedUrl' | 'gscPropertyUrl' | 'permissionLevel' | 'analytics' | 'indexing' | 'latestError' | 'updatedAt'>;
+declare function analyticsStatusToSyncStatus(status: LifecycleSiteLike['analytics']['status']): GscdumpUserSite['syncStatus'];
+declare function lifecycleSiteToUserSite(site: LifecycleSiteLike): GscdumpUserSite;
+declare function lifecycleSiteToSyncStatus(site: LifecycleSiteLike): GscdumpSyncStatusResponse;
 declare function findLifecycleSite<TSite extends LifecycleSiteLike>(lifecycle: {
   sites: readonly TSite[];
 }, siteIdOrPropertyUrl: string): TSite | null;
@@ -712,7 +830,6 @@ declare function reachLivenessRatio(daily: Array<{
 declare function classifyHealthStage(input: SiteTriageInput): HealthVerdict;
 declare function classifyReachStage(input: SiteTriageInput): ReachVerdict;
 declare function classifySiteTriage(input: SiteTriageInput): SiteTriage;
-declare function serializeWebhookPayload(payload: string | object): string;
 declare function verifyWebhookSignature(payload: string | object, signature: string | null | undefined, secret: string): Promise<boolean>;
 /**
  * Errors-as-values core for {@link parseWebhookPayload}: a failed HMAC signature
@@ -723,34 +840,14 @@ declare function verifyWebhookSignature(payload: string | object, signature: str
 declare function parseWebhookPayloadResult<TData extends Record<string, unknown> = Record<string, unknown>>(payload: string | object, options?: {
   secret?: string;
   signature?: string | null;
-  headers?: PartnerWebhookHeaders$1 | Headers;
+  headers?: PartnerWebhookHeaders | Headers;
   validateSignature?: boolean;
-}): Promise<Result<WebhookEnvelope$1<TData>, PartnerApiError>>;
+}): Promise<Result<WebhookEnvelope<TData>, PartnerApiError>>;
 declare function parseWebhookPayload<TData extends Record<string, unknown> = Record<string, unknown>>(payload: string | object, options?: {
   secret?: string;
   signature?: string | null;
-  headers?: PartnerWebhookHeaders$1 | Headers;
+  headers?: PartnerWebhookHeaders | Headers;
   validateSignature?: boolean;
-}): Promise<WebhookEnvelope$1<TData>>;
-declare function readWebhookHeaders(headers: Headers | PartnerWebhookHeaders$1 | null | undefined): Required<PartnerWebhookHeaders$1>;
-type ArbitrarySqlQuery = import__gscdump_contracts_archetypes.ArbitrarySqlQuery;
-type ArchetypeExecutionClass = import__gscdump_contracts_archetypes.ArchetypeExecutionClass;
-type ArchetypeFacet = import__gscdump_contracts_archetypes.ArchetypeFacet;
-type ArchetypeQuery = import__gscdump_contracts_archetypes.ArchetypeQuery;
-type ArchetypeQueryBase = import__gscdump_contracts_archetypes.ArchetypeQueryBase;
-type ArchetypeResult = import__gscdump_contracts_archetypes.ArchetypeResult;
-type ArchetypeResultRow = import__gscdump_contracts_archetypes.ArchetypeResultRow;
-type ArchetypeResultSource = import__gscdump_contracts_archetypes.ArchetypeResultSource;
-type AuxCloudOnlyQuery = import__gscdump_contracts_archetypes.AuxCloudOnlyQuery;
-type DateRange = import__gscdump_contracts_archetypes.DateRange;
-type EntityDailySparklineQuery = import__gscdump_contracts_archetypes.EntityDailySparklineQuery;
-type EntityDailyTimeseriesQuery = import__gscdump_contracts_archetypes.EntityDailyTimeseriesQuery;
-type MultiSeriesStackedDailyQuery = import__gscdump_contracts_archetypes.MultiSeriesStackedDailyQuery;
-type QueryArchetype = import__gscdump_contracts_archetypes.QueryArchetype;
-type ResolvedArchetypeQuery = import__gscdump_contracts_archetypes.ResolvedArchetypeQuery;
-type SingleRowLookupQuery = import__gscdump_contracts_archetypes.SingleRowLookupQuery;
-type SiteDailyTimeseriesQuery = import__gscdump_contracts_archetypes.SiteDailyTimeseriesQuery;
-type TopNBreakdownQuery = import__gscdump_contracts_archetypes.TopNBreakdownQuery;
-type TwoDimensionDetailQuery = import__gscdump_contracts_archetypes.TwoDimensionDetailQuery;
-type WireDateRange = import__gscdump_contracts_archetypes.WireDateRange;
-export { ARCHETYPE_EXECUTION_CLASS, type AddPartnerTeamMemberParams, type AnalysisSourcesOptions, type AnalyticsClient, type AnalyticsClientOptions, type AnalyticsFetch, type AnalyticsFetchOptions, type AnalyticsHeaders, type ArbitrarySqlQuery, type ArchetypeExecutionClass, type ArchetypeFacet, type ArchetypeQuery, type ArchetypeQueryBase, type ArchetypeResult, type ArchetypeResultRow, type ArchetypeResultSource, type AuxCloudOnlyQuery, type BackfillRange, type BackfillResponse, type BindPartnerSiteTeamParams, type BuilderState, type BulkRegisterPartnerSiteResult, type BulkRegisterPartnerSitesParams, type BulkRegisterPartnerSitesResponse, CANONICAL_WEBHOOK_EVENTS, COMPARE_OPTIONS, COUNTRY_NAMES, CWV_GOOD_CLS, CWV_GOOD_INP, CWV_GOOD_LCP, CWV_POOR_CLS, CWV_POOR_INP, CWV_POOR_LCP, type CalendarPeriod, type CanonicalDailyRow, type CanonicalWebhookEventType, type ClassifySearchConsoleStageInput, type CompareMode, type CreatePartnerTeamParams, type CreateWebhookEnvelopeOptions, type CustomPeriod, type CwvBucket, DEFAULT_SEARCH_TYPE, type DailyAnonInput, type DataDetailOptions, type DataQueryOptions, type DateRange, type DateRangeResult, type DeletePartnerUserResponse, type EntityDailySparklineQuery, type EntityDailyTimeseriesQuery, GSC_COLUMN_OPTIONS, GSC_PERIOD_OPTIONS, GSC_PERIOD_OPTIONS_LONG, GSC_STABLE_LATENCY_DAYS, type GscAnalyzerAccent, type GscAnalyzerCapabilities, type GscAnalyzerCapability, type GscAnalyzerDefinition, type GscAnalyzerDefinitionWithCapability, type GscAnalyzerInsightCard, type GscAnalyzerKind, type GscAnalyzerPanelResult, type GscAnalyzerPanelSpec, type GscAnalyzerStatTile, type GscClassifiedError, type GscColumn, type GscColumnOption, type GscComparisonFilter, type GscConsoleUrlOpts, type GscDailySummary, type GscErrorStatus, type GscRowTotals, type GscdumpAnalysisParams, type GscdumpAnalysisPreset, type GscdumpAnalysisResponse, type GscdumpAnalysisSourcesResponse, type GscdumpAvailableSite, type GscdumpCanonicalMismatchesResponse, type GscdumpDataDetailResponse, type GscdumpDataResponse, type GscdumpDataRow, type GscdumpDateRangeParams, type GscdumpIndexPercentResponse, type GscdumpIndexingDiagnosticsResponse, type GscdumpIndexingResponse, type GscdumpIndexingUrlStatus, type GscdumpIndexingUrlsResponse, type GscdumpKeywordSparklinesParams, type GscdumpKeywordSparklinesResponse, type GscdumpMeta, type GscdumpPageTrendParams, type GscdumpPageTrendResponse, type GscdumpPermissionRecovery, type GscdumpQueryTrendParams, type GscdumpQueryTrendResponse, type GscdumpSiteRegistration, type GscdumpSitemap, type GscdumpSitemapChangesResponse, type GscdumpSitemapHistory, type GscdumpSitemapsResponse, type GscdumpSyncStatusResponse, type GscdumpTeamMemberRow, type GscdumpTeamRow, type GscdumpTopAssociationParams, type GscdumpTopAssociationResponse, type GscdumpTotals, type GscdumpUserRegistration, type GscdumpUserSettings, type GscdumpUserSite, type GscdumpUserStatus, type GscdumpUserTokenUpdate, type HealthStage, type HealthVerdict, type IndexingDiagnosticsParams, type IndexingIssue, type IndexingIssueDetail, type IndexingUrlsParams, type InspectionHistoryResponse, type InspectionIndex, type IssueGroup, type IssueSeverity, type LifecycleSiteLike, type MultiSeriesStackedDailyQuery, PERIOD_PRESETS, PartnerApiError, type PartnerClient, type PartnerClientOptions, type PartnerErrorInfo, type PartnerErrorKind, type PartnerFetch, type PartnerFetchOptions, type PartnerHeaders, type PartnerLifecycleAccount, type PartnerLifecycleResponse, type PartnerLifecycleSite, type PartnerWebhookData, type PartnerWebhookHeaders, type PeerBaselineInput, type PeerConfidence, type PeerStanding, type Period, type PeriodOptions, type PeriodPreset, type QueryArchetype, type RawDailyRow, type ReachStage, type ReachVerdict, type RegisterPartnerSiteParams, type RegisterPartnerUserParams, type ResolvedArchetypeQuery, type RollingPeriod, type RollupEnvelope, SITE_TYPE_BASELINE, type SearchConsoleStage, type SearchConsoleStageEvidence, type SearchConsoleStageIssue, type SearchConsoleStageKey, type SearchConsoleStagePage, type SearchConsoleStageSeverity, type SearchConsoleStageSitemap, type SearchConsoleStageSummary, type SearchConsoleStageTrajectory, type SearchTypeOptions, type SingleRowLookupQuery, type SiteBaseline, type SiteDailyTimeseriesQuery, type SiteTriage, type SiteTriageInput, type SiteType, type SiteTypeBaseline, type SourceRangeOptions, type TopNBreakdownQuery, type TriageEvidence, type TwoDimensionDetailQuery, type UpdatePartnerUserTokensParams, VALID_WEBHOOK_EVENTS, WEBHOOK_CONTRACT_VERSION, WEBHOOK_CONTRACT_VERSION_HEADER, WEBHOOK_DELIVERY_HEADER, WEBHOOK_EVENT_HEADER, WEBHOOK_SIGNATURE_HEADER, WEBHOOK_TIMESTAMP_HEADER, type WebhookEnvelope, type WebhookEventType, type WhoamiResponse, type WireDateRange, analyticsStatusToSyncStatus, andFilter, arbitrarySql, auxCloudOnly, classifyGscError, classifyHealthStage, classifyReachStage, classifySearchConsoleStage, classifySiteTriage, coerceRowMetrics, compareRange, countryName, coverageLabel, coverageLabels, createAnalyticsClient, createPartnerClient, cwvBucket, dateFilter, dateRangeOptionsQuery, defineGscAnalyzer, derivePeerStanding, deriveSiteBaseline, enrichIssueDetails, entityDailySparkline, entityDailyTimeseries, findLifecycleSite, formatPartnerError, getGscUnstableCutoffDate, gscConsoleUrl, investigationStatusConfig, isCustomPeriod, isPartnerError, issueDetails, issueGroups, issueTypeToGroup, lifecycleSiteToSyncStatus, lifecycleSiteToUserSite, multiSeriesStackedDaily, normalizeSiteType, nuxtSeoTips, parseCustomPeriod, parseWebhookPayload, parseWebhookPayloadResult, partnerErrorToException, periodToDateRange, periodToDays, positionFor, reachLivenessRatio, readWebhookHeaders, searchTypeQuery, serializeWebhookPayload, severityOrder, singleRowLookup, siteDailyTimeseries, siteTypeBaseline, siteUrlToHostname, sourceInfoQuery, splitOpportunityTitle, summarizeDailyRows, tablesQuery, toPartnerError, topNBreakdown, truncateQuery, twoDimensionDetail, verifyWebhookSignature, weightedAnonPct, withDefaultSearchType };
+}): Promise<WebhookEnvelope<TData>>;
+declare function readWebhookHeaders(headers: Headers | PartnerWebhookHeaders | null | undefined): Required<PartnerWebhookHeaders>;
+export { type AnalysisSourcesOptions, type AnalyticsClient, type AnalyticsClientOptions, type AnalyticsFetch, type AnalyticsFetchOptions, type AnalyticsHeaders, type BuilderStateToArchetypeOptions, CANONICAL_WEBHOOK_EVENTS, COMPARE_OPTIONS, CWV_GOOD_CLS, CWV_GOOD_INP, CWV_GOOD_LCP, CWV_POOR_CLS, CWV_POOR_INP, CWV_POOR_LCP, type CalendarPeriod, type CanonicalDailyRow, type ClassifySearchConsoleStageInput, type CompareMode, type CustomPeriod, type CwvBucket, DEFAULT_SEARCH_TYPE, type DailyAnonInput, type DateRangeResult, GSC_COLUMN_OPTIONS, GSC_PERIOD_OPTIONS, GSC_PERIOD_OPTIONS_LONG, GSC_STABLE_LATENCY_DAYS, type GscAnalyzerAccent, type GscAnalyzerCapabilities, type GscAnalyzerCapability, type GscAnalyzerDefinition, type GscAnalyzerDefinitionWithCapability, type GscAnalyzerInsightCard, type GscAnalyzerKind, type GscAnalyzerPanelResult, type GscAnalyzerPanelSpec, type GscAnalyzerStatTile, type GscClassifiedError, type GscColumn, type GscColumnOption, type GscConsoleUrlOpts, type GscDailySummary, type GscErrorStatus, type GscRowTotals, type HealthStage, type HealthVerdict, type IndexingIssue, type IndexingIssueDetail, type IssueGroup, type IssueSeverity, type LifecycleSiteLike, PERIOD_PRESETS, PartnerApiError, type PartnerClient, type PartnerClientOptions, type PartnerErrorInfo, type PartnerErrorKind, type PartnerFetch, type PartnerFetchOptions, type PartnerHeaders, type PeerBaselineInput, type PeerConfidence, type PeerStanding, type Period, type PeriodOptions, type PeriodPreset, type RawDailyRow, type ReachStage, type ReachVerdict, type RollingPeriod, SITE_TYPE_BASELINE, type SearchConsoleStage, type SearchConsoleStageEvidence, type SearchConsoleStageIssue, type SearchConsoleStageKey, type SearchConsoleStagePage, type SearchConsoleStageSeverity, type SearchConsoleStageSitemap, type SearchConsoleStageSummary, type SearchConsoleStageTrajectory, type SearchTypeOptions, type SiteBaseline, type SiteTriage, type SiteTriageInput, type SiteType, type SiteTypeBaseline, type SourceRangeOptions, type TriageEvidence, VALID_WEBHOOK_EVENTS, WEBHOOK_CONTRACT_VERSION, WEBHOOK_CONTRACT_VERSION_HEADER, WEBHOOK_DELIVERY_HEADER, WEBHOOK_EVENT_HEADER, WEBHOOK_SIGNATURE_HEADER, WEBHOOK_TIMESTAMP_HEADER, analyticsStatusToSyncStatus, archetypeSeamSupportsQuery, builderStateToArchetype, classifyGscError, classifyHealthStage, classifyReachStage, classifySearchConsoleStage, classifySiteTriage, coerceRowMetrics, compareRange, countryName, createAnalyticsClient, createPartnerClient, cwvBucket, dateRangeOptionsQuery, defineGscAnalyzer, derivePeerStanding, deriveSiteBaseline, extractWireDateRange, findLifecycleSite, getGscUnstableCutoffDate, gscConsoleUrl, isCustomPeriod, issueDetails, issueGroups, lifecycleSiteToSyncStatus, lifecycleSiteToUserSite, normalizeSiteType, parseCustomPeriod, parseWebhookPayload, parseWebhookPayloadResult, partnerErrorToException, periodToDateRange, periodToDays, positionFor, reachLivenessRatio, readWebhookHeaders, searchTypeQuery, severityOrder, siteTypeBaseline, siteUrlToHostname, sourceInfoQuery, summarizeDailyRows, tablesQuery, toPartnerError, truncateQuery, verifyWebhookSignature, weightedAnonPct, withDefaultSearchType };

package/dist/index.mjs

@@ -1,12 +1,12 @@
 import { analyticsEndpoints } from "@gscdump/contracts/analytics";
 import { err, ok, unwrapResult } from "gscdump/result";
 import { ofetch } from "ofetch";
-import { ARCHETYPE_EXECUTION_CLASS as ARCHETYPE_EXECUTION_CLASS$1, arbitrarySql as arbitrarySql$1, auxCloudOnly as auxCloudOnly$1, entityDailySparkline as entityDailySparkline$1, entityDailyTimeseries as entityDailyTimeseries$1, multiSeriesStackedDaily as multiSeriesStackedDaily$1, singleRowLookup as singleRowLookup$1, siteDailyTimeseries as siteDailyTimeseries$1, topNBreakdown as topNBreakdown$1, twoDimensionDetail as twoDimensionDetail$1 } from "@gscdump/contracts/archetypes";
+import { entityDailyTimeseries, multiSeriesStackedDaily, siteDailyTimeseries, topNBreakdown, twoDimensionDetail } from "@gscdump/contracts/archetypes";
+import { extractDateRange, normalizeFilter } from "gscdump/query";
 import { partnerEndpoints } from "@gscdump/contracts/partner";
 import { resolveWindow } from "@gscdump/engine/period";
 import { endOfMonth, format, startOfMonth, startOfQuarter, startOfWeek, subDays, subMonths } from "date-fns";
 import { CANONICAL_WEBHOOK_EVENTS, VALID_WEBHOOK_EVENTS, WEBHOOK_CONTRACT_VERSION, WEBHOOK_CONTRACT_VERSION_HEADER, WEBHOOK_CONTRACT_VERSION_HEADER as WEBHOOK_CONTRACT_VERSION_HEADER$1, WEBHOOK_DELIVERY_HEADER, WEBHOOK_DELIVERY_HEADER as WEBHOOK_DELIVERY_HEADER$1, WEBHOOK_EVENT_HEADER, WEBHOOK_EVENT_HEADER as WEBHOOK_EVENT_HEADER$1, WEBHOOK_SIGNATURE_HEADER, WEBHOOK_SIGNATURE_HEADER as WEBHOOK_SIGNATURE_HEADER$1, WEBHOOK_TIMESTAMP_HEADER, WEBHOOK_TIMESTAMP_HEADER as WEBHOOK_TIMESTAMP_HEADER$1, partnerWebhookEnvelopeSchema } from "@gscdump/contracts";
-export * from "@gscdump/contracts";
 const DEFAULT_SEARCH_TYPE = "web";
 function isAnalysisSourcesOptions(value) {
 	return !!value && typeof value === "object" && !Array.isArray(value);
@@ -75,25 +75,6 @@ function dataDetailQuery(state, options) {
 	if (opts?.comparison) query.qc = stableJson$1(withDefaultSearchType(opts.comparison, scoped.searchType));
 	return query;
 }
-function analysisQuery(params) {
-	const query = {
-		preset: params.preset,
-		startDate: params.startDate,
-		endDate: params.endDate
-	};
-	if (params.prevStartDate) query.prevStartDate = params.prevStartDate;
-	if (params.prevEndDate) query.prevEndDate = params.prevEndDate;
-	if (params.brandTerms) query.brandTerms = params.brandTerms;
-	if (params.limit != null) query.limit = params.limit;
-	if (params.offset != null) query.offset = params.offset;
-	if (params.search) query.search = params.search;
-	if (params.minImpressions != null) query.minImpressions = params.minImpressions;
-	if (params.minPosition != null) query.minPosition = params.minPosition;
-	if (params.maxPosition != null) query.maxPosition = params.maxPosition;
-	if (params.maxCtr != null) query.maxCtr = params.maxCtr;
-	query.searchType = params.searchType ?? "web";
-	return query;
-}
 function indexingUrlsQuery(params = {}) {
 	const query = {};
 	if (params.limit != null) query.limit = params.limit;
@@ -110,12 +91,6 @@ function indexingDiagnosticsQuery(params = {}) {
 	if (params.sampleLimit != null) query.sampleLimit = params.sampleLimit;
 	return query;
 }
-function dateRangeQuery(params) {
-	return {
-		startDate: params.startDate,
-		endDate: params.endDate
-	};
-}
 function queryTrendQuery(params) {
 	const query = {
 		startDate: params.startDate,
@@ -179,13 +154,6 @@ function toPartnerError(error) {
 		data
 	});
 }
-function isPartnerError(error) {
-	return error instanceof PartnerApiError;
-}
-function formatPartnerError(error) {
-	const status = error.statusCode != null ? ` (${error.statusCode})` : "";
-	return `[${error.kind}]${status} ${error.message}`;
-}
 function partnerErrorToException(error) {
 	return error;
 }
@@ -280,6 +248,16 @@ function createAnalyticsClient(options = {}) {
 			const endpoint = analyticsEndpoints.listSites;
 			return request(endpoint.path, { method: endpoint.method }, endpoint.response);
 		},
+		getBulkSources(params) {
+			const endpoint = analyticsEndpoints.getBulkSources;
+			const { siteIds, tables, ...options } = params;
+			const query = tablesQuery(tables, options);
+			if (siteIds?.length) query.siteIds = [...new Set(siteIds.filter(Boolean))].join(",");
+			return request(endpoint.path, {
+				method: endpoint.method,
+				query
+			}, endpoint.response);
+		},
 		getSourceInfo(siteId, options) {
 			const endpoint = analyticsEndpoints.getSourceInfo;
 			return request(endpoint.path(siteId), {
@@ -294,6 +272,10 @@ function createAnalyticsClient(options = {}) {
 				query: tablesQuery(tables, options)
 			}, endpoint.response);
 		},
+		getQueryDimSource(siteId) {
+			const endpoint = analyticsEndpoints.getQueryDimSource;
+			return request(endpoint.path(siteId), { method: endpoint.method }, endpoint.response);
+		},
 		analyze(siteId, params) {
 			const endpoint = analyticsEndpoints.analyze;
 			return request(endpoint.path(siteId), {
@@ -302,14 +284,6 @@ function createAnalyticsClient(options = {}) {
 				dedupe: true
 			});
 		},
-		queryRows(siteId, state) {
-			const endpoint = analyticsEndpoints.queryRows;
-			return request(endpoint.path(siteId), {
-				method: endpoint.method,
-				body: withDefaultSearchType(state),
-				dedupe: true
-			}, endpoint.response);
-		},
 		getRollup(siteId, rollupId, params) {
 			const endpoint = analyticsEndpoints.getRollup;
 			return request(endpoint.path(siteId, rollupId), {
@@ -401,16 +375,127 @@ function weightedAnonPct(days, window = 28) {
 	}
 	return totalImpressions > 0 ? weighted / totalImpressions : null;
 }
-const ARCHETYPE_EXECUTION_CLASS = ARCHETYPE_EXECUTION_CLASS$1;
-const arbitrarySql = arbitrarySql$1;
-const auxCloudOnly = auxCloudOnly$1;
-const entityDailySparkline = entityDailySparkline$1;
-const entityDailyTimeseries = entityDailyTimeseries$1;
-const multiSeriesStackedDaily = multiSeriesStackedDaily$1;
-const singleRowLookup = singleRowLookup$1;
-const siteDailyTimeseries = siteDailyTimeseries$1;
-const topNBreakdown = topNBreakdown$1;
-const twoDimensionDetail = twoDimensionDetail$1;
+const KNOWN_DIMENSIONS = /* @__PURE__ */ new Set([
+	"query",
+	"queryCanonical",
+	"page",
+	"country",
+	"device",
+	"searchAppearance",
+	"date",
+	"hour"
+]);
+const DATE_RANGE_OPERATORS = /* @__PURE__ */ new Set([
+	"between",
+	"gte",
+	"gt",
+	"lte",
+	"lt"
+]);
+const EQUALITY_OPERATORS = /* @__PURE__ */ new Set(["equals", "eq"]);
+const ENTITY_DIMENSIONS = [
+	"page",
+	"query",
+	"queryCanonical"
+];
+function collectEqualityMatches(filter, out) {
+	if (!filter) return true;
+	if (filter._groupType === "or") return false;
+	for (const f of filter._filters) {
+		if (f.dimension === "date") {
+			if (!DATE_RANGE_OPERATORS.has(f.operator)) return false;
+			continue;
+		}
+		if (!EQUALITY_OPERATORS.has(f.operator) || !KNOWN_DIMENSIONS.has(f.dimension)) return false;
+		const dim = f.dimension;
+		const existing = out.get(dim);
+		if (existing !== void 0 && existing !== f.expression) return false;
+		out.set(dim, f.expression);
+	}
+	for (const nested of filter._nestedGroups ?? []) if (!collectEqualityMatches(nested, out)) return false;
+	return true;
+}
+function extractWireDateRange(filter) {
+	const { startDate, endDate } = extractDateRange(filter);
+	return startDate && endDate ? {
+		start: startDate,
+		end: endDate
+	} : null;
+}
+function builderStateToArchetype(siteId, state, opts = {}) {
+	const range = extractWireDateRange(state.filter);
+	if (!range) return null;
+	const matches = /* @__PURE__ */ new Map();
+	if (!collectEqualityMatches(normalizeFilter(state.filter), matches)) return null;
+	const dims = state.dimensions ?? [];
+	if (dims.some((d) => !KNOWN_DIMENSIONS.has(d))) return null;
+	if (dims.includes("hour") || dims.includes("searchAppearance")) return null;
+	const searchType = opts.searchType;
+	const cmp = opts.compareRange;
+	const order = state.orderBy ? {
+		metric: state.orderBy.column,
+		dir: state.orderBy.dir
+	} : void 0;
+	if (dims.length === 1 && dims[0] === "date") {
+		const entityDims = ENTITY_DIMENSIONS.filter((c) => matches.has(c));
+		if (entityDims.length > 1) return null;
+		if (entityDims.length === 1) {
+			const dim = entityDims[0];
+			if (matches.size > 1) return null;
+			return entityDailyTimeseries(siteId, range, {
+				dimension: dim,
+				value: matches.get(dim)
+			}, {
+				searchType,
+				compareRange: cmp
+			});
+		}
+		if (matches.size > 0) return null;
+		return siteDailyTimeseries(siteId, range, {
+			searchType,
+			compareRange: cmp
+		});
+	}
+	if (dims.length === 2 && dims.includes("date")) {
+		if (matches.size > 0) return null;
+		return multiSeriesStackedDaily(siteId, range, dims.find((d) => d !== "date"), {
+			searchType,
+			compareRange: cmp
+		});
+	}
+	if (dims.length === 1 && dims[0] !== "date") {
+		const primary = dims[0];
+		if (matches.has(primary)) return null;
+		const facets = [...matches.entries()].map(([column, value]) => ({
+			column,
+			op: "eq",
+			value
+		}));
+		return topNBreakdown(siteId, range, primary, {
+			searchType,
+			compareRange: cmp,
+			...order ? { orderBy: order } : {},
+			limit: state.rowLimit ?? 50,
+			...state.startRow ? { offset: state.startRow } : {},
+			...facets.length ? { facets } : {}
+		});
+	}
+	if (dims.length === 2 && !dims.includes("date")) {
+		const set = new Set(dims);
+		if (!set.has("page") || !set.has("query")) return null;
+		if (matches.size > 0) return null;
+		return twoDimensionDetail(siteId, range, {
+			searchType,
+			compareRange: cmp,
+			...order ? { orderBy: order } : {},
+			...state.rowLimit ? { limit: state.rowLimit } : {}
+		});
+	}
+	return null;
+}
+function archetypeSeamSupportsQuery(query) {
+	return query.archetype !== "two-dimension-detail";
+}
 function normalizeLifecycleUrl(url) {
 	return (url || "").replace(/^sc-domain:/, "").replace(/^https?:\/\//, "").replace(/^www\./, "").replace(/\/$/, "").toLowerCase();
 }
@@ -495,17 +580,6 @@ function findLifecycleSite(lifecycle, siteIdOrPropertyUrl) {
 	return lifecycle.sites.find((site) => site.siteId === siteIdOrPropertyUrl || site.externalSiteId === siteIdOrPropertyUrl || !!propertyKey && normalizeGscPropertyKey(site.gscPropertyUrl) === propertyKey || !site.gscPropertyUrl && normalizeLifecycleUrl(site.requestedUrl) === normalized || !propertyKey && normalizeLifecycleUrl(site.requestedUrl) === normalized) ?? null;
 }
 const endpoints = partnerEndpoints;
-function validateAnalysisParamsResult(params) {
-	if ((params.preset === "non-brand" || params.preset === "brand-only") && !params.brandTerms?.trim()) return err(new PartnerApiError({
-		kind: "validation",
-		statusCode: 400,
-		message: "brandTerms is required for brand/non-brand presets"
-	}));
-	return ok(params);
-}
-function assertAnalysisParams(params) {
-	unwrapResult(validateAnalysisParamsResult(params), partnerErrorToException);
-}
 function sleep(ms) {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -581,6 +655,13 @@ function createPartnerClient(options = {}) {
 		}));
 		return ok(lifecycleSiteToSyncStatus(site));
 	}
+	function postSitemapAction(siteId, action) {
+		const body = shouldValidate("request") ? endpoints.postSitemaps.body.parse(action) : action;
+		return request(endpoints.postSitemaps.path(siteId), {
+			method: endpoints.postSitemaps.method,
+			body
+		}, endpoints.postSitemaps.response);
+	}
 	return {
 		registerUser(params) {
 			const body = shouldValidate("request") ? endpoints.registerUser.body.parse(params) : params;
@@ -614,6 +695,9 @@ function createPartnerClient(options = {}) {
 		getAvailableSites(userId) {
 			return request(endpoints.getAvailableSites.path(userId), { method: endpoints.getAvailableSites.method }, endpoints.getAvailableSites.response);
 		},
+		getUserSiteIntIdCrosswalk(userId) {
+			return request(endpoints.getUserSiteIntIdCrosswalk.path(userId), { method: endpoints.getUserSiteIntIdCrosswalk.method }, endpoints.getUserSiteIntIdCrosswalk.response);
+		},
 		registerSite(params) {
 			const body = shouldValidate("request") ? endpoints.registerSite.body.parse(params) : params;
 			return request(endpoints.registerSite.path, {
@@ -628,6 +712,20 @@ function createPartnerClient(options = {}) {
 				body
 			}, endpoints.bulkRegisterSites.response);
 		},
+		requestSiteVerificationToken(params) {
+			const body = shouldValidate("request") ? endpoints.requestSiteVerificationToken.body.parse(params) : params;
+			return request(endpoints.requestSiteVerificationToken.path, {
+				method: endpoints.requestSiteVerificationToken.method,
+				body
+			}, endpoints.requestSiteVerificationToken.response);
+		},
+		addAndVerifySite(params) {
+			const body = shouldValidate("request") ? endpoints.addAndVerifySite.body.parse(params) : params;
+			return request(endpoints.addAndVerifySite.path, {
+				method: endpoints.addAndVerifySite.method,
+				body
+			}, endpoints.addAndVerifySite.response);
+		},
 		deleteUser(userId) {
 			return request(endpoints.deleteUser.path(userId), { method: endpoints.deleteUser.method }, endpoints.deleteUser.response);
 		},
@@ -663,14 +761,6 @@ function createPartnerClient(options = {}) {
 				query: dataDetailQuery(state, queryOptions)
 			}, endpoints.getDataDetail.response);
 		},
-		getAnalysis(siteId, params) {
-			assertAnalysisParams(params);
-			const query = shouldValidate("request") ? endpoints.getAnalysis.query.parse(params) : params;
-			return request(endpoints.getAnalysis.path(siteId), {
-				method: endpoints.getAnalysis.method,
-				query: analysisQuery(query)
-			}, endpoints.getAnalysis.response);
-		},
 		getSitemaps(siteId) {
 			return request(endpoints.getSitemaps.path(siteId), { method: endpoints.getSitemaps.method }, endpoints.getSitemaps.response);
 		},
@@ -680,20 +770,33 @@ function createPartnerClient(options = {}) {
 				query: { days }
 			}, endpoints.getSitemapChanges.response);
 		},
-		submitSitemap(siteId, sitemapUrl, action = "submit") {
-			return request(endpoints.submitSitemap.path(siteId), {
-				method: endpoints.submitSitemap.method,
-				body: {
-					sitemapUrl,
-					action
-				}
-			});
+		getSitemapMembership(siteId, params) {
+			const body = shouldValidate("request") ? endpoints.getSitemapMembership.body.parse(params) : params;
+			return request(endpoints.getSitemapMembership.path(siteId), {
+				method: endpoints.getSitemapMembership.method,
+				body,
+				dedupe: true
+			}, endpoints.getSitemapMembership.response);
 		},
-		refreshSitemaps(siteId) {
-			return request(endpoints.refreshSitemaps.path(siteId), {
-				method: endpoints.refreshSitemaps.method,
-				body: { action: "refresh" }
+		postSitemapAction,
+		async submitSitemap(siteId, sitemapUrl, action = "submit") {
+			const response = await postSitemapAction(siteId, {
+				action,
+				sitemapUrl
 			});
+			const expected = action === "submit" ? "submitted" : "deleted";
+			if (response.action !== expected) throw new TypeError(`Unexpected sitemap action response: expected ${expected}, got ${response.action}`);
+			return response;
+		},
+		async refreshSitemaps(siteId) {
+			const response = await postSitemapAction(siteId, { action: "refresh" });
+			if (response.action !== "refreshed") throw new TypeError(`Unexpected sitemap action response: expected refreshed, got ${response.action}`);
+			return response;
+		},
+		async autoDiscoverSitemap(siteId) {
+			const response = await postSitemapAction(siteId, { action: "auto-discover" });
+			if (response.action !== "auto-discover") throw new TypeError(`Unexpected sitemap action response: expected auto-discover, got ${response.action}`);
+			return response;
 		},
 		getIndexing(siteId, days = 28) {
 			return request(endpoints.getIndexing.path(siteId), {
@@ -771,36 +874,6 @@ function createPartnerClient(options = {}) {
 		getCanonicalMismatches(siteId) {
 			return request(endpoints.getCanonicalMismatches.path(siteId), { method: endpoints.getCanonicalMismatches.method }, endpoints.getCanonicalMismatches.response);
 		},
-		getContentVelocity(siteId, days) {
-			return request(endpoints.getContentVelocity.path(siteId), {
-				method: endpoints.getContentVelocity.method,
-				query: days == null ? void 0 : { days }
-			});
-		},
-		getCtrCurve(siteId, params) {
-			const endpoint = endpoints.getCtrCurve;
-			const query = shouldValidate("request") ? endpoint.query.parse(params) : params;
-			return request(endpoint.path(siteId), {
-				method: endpoint.method,
-				query: dateRangeQuery(query)
-			});
-		},
-		getDarkTraffic(siteId, params) {
-			const endpoint = endpoints.getDarkTraffic;
-			const query = shouldValidate("request") ? endpoint.query.parse(params) : params;
-			return request(endpoint.path(siteId), {
-				method: endpoint.method,
-				query: dateRangeQuery(query)
-			});
-		},
-		getDeviceGap(siteId, params) {
-			const endpoint = endpoints.getDeviceGap;
-			const query = shouldValidate("request") ? endpoint.query.parse(params) : params;
-			return request(endpoint.path(siteId), {
-				method: endpoint.method,
-				query: dateRangeQuery(query)
-			});
-		},
 		getIndexPercent(siteId, params = {}) {
 			const query = shouldValidate("request") ? endpoints.getIndexPercent.query.parse(params) : params;
 			return request(endpoints.getIndexPercent.path(siteId), {
@@ -808,22 +881,6 @@ function createPartnerClient(options = {}) {
 				query
 			}, endpoints.getIndexPercent.response);
 		},
-		getKeywordBreadth(siteId, params) {
-			const endpoint = endpoints.getKeywordBreadth;
-			const query = shouldValidate("request") ? endpoint.query.parse(params) : params;
-			return request(endpoint.path(siteId), {
-				method: endpoint.method,
-				query: dateRangeQuery(query)
-			});
-		},
-		getPositionDistribution(siteId, params) {
-			const endpoint = endpoints.getPositionDistribution;
-			const query = shouldValidate("request") ? endpoint.query.parse(params) : params;
-			return request(endpoint.path(siteId), {
-				method: endpoint.method,
-				query: dateRangeQuery(query)
-			});
-		},
 		createTeam(params) {
 			const body = shouldValidate("request") ? endpoints.createTeam.body.parse(params) : params;
 			return request(endpoints.createTeam.path, {
@@ -832,13 +889,14 @@ function createPartnerClient(options = {}) {
 			}, endpoints.createTeam.response);
 		},
 		renameTeam(teamId, params) {
+			const body = shouldValidate("request") ? endpoints.renameTeam.body.parse(params) : params;
 			return request(endpoints.renameTeam.path(teamId), {
 				method: endpoints.renameTeam.method,
-				body: params
-			});
+				body
+			}, endpoints.renameTeam.response);
 		},
 		deleteTeam(teamId) {
-			return request(endpoints.deleteTeam.path(teamId), { method: endpoints.deleteTeam.method });
+			return request(endpoints.deleteTeam.path(teamId), { method: endpoints.deleteTeam.method }, endpoints.deleteTeam.response);
 		},
 		listTeamMembers(teamId) {
 			return request(endpoints.listTeamMembers.path(teamId), { method: endpoints.listTeamMembers.method }, endpoints.listTeamMembers.response);
@@ -851,13 +909,14 @@ function createPartnerClient(options = {}) {
 			}, endpoints.addTeamMember.response);
 		},
 		updateTeamMemberRole(teamId, userId, params) {
+			const body = shouldValidate("request") ? endpoints.updateTeamMemberRole.body.parse(params) : params;
 			return request(endpoints.updateTeamMemberRole.path(teamId, userId), {
 				method: endpoints.updateTeamMemberRole.method,
-				body: params
-			});
+				body
+			}, endpoints.updateTeamMemberRole.response);
 		},
 		removeTeamMember(teamId, userId) {
-			return request(endpoints.removeTeamMember.path(teamId, userId), { method: endpoints.removeTeamMember.method });
+			return request(endpoints.removeTeamMember.path(teamId, userId), { method: endpoints.removeTeamMember.method }, endpoints.removeTeamMember.response);
 		},
 		bindSiteToTeam(userId, siteId, params) {
 			const body = shouldValidate("request") ? endpoints.bindSiteToTeam.body.parse(params) : params;
@@ -865,6 +924,16 @@ function createPartnerClient(options = {}) {
 				method: endpoints.bindSiteToTeam.method,
 				body
 			}, endpoints.bindSiteToTeam.response);
+		},
+		getTeamCatalog(teamId) {
+			return request(endpoints.getTeamCatalog.path(teamId), { method: endpoints.getTeamCatalog.method }, endpoints.getTeamCatalog.response);
+		},
+		bindTeamCatalog(teamId, params) {
+			const body = shouldValidate("request") ? endpoints.bindTeamCatalog.body.parse(params) : params;
+			return request(endpoints.bindTeamCatalog.path(teamId), {
+				method: endpoints.bindTeamCatalog.method,
+				body
+			}, endpoints.bindTeamCatalog.response);
 		}
 	};
 }
@@ -945,12 +1014,6 @@ function siteUrlToHostname(url) {
 		return;
 	}
 }
-function splitOpportunityTitle(title) {
-	return title.split(/("[^"]+")/g).filter(Boolean).map((part) => ({
-		text: part.startsWith("\"") && part.endsWith("\"") ? part.slice(1, -1) : part,
-		highlight: part.startsWith("\"") && part.endsWith("\"")
-	}));
-}
 function gscConsoleUrl(opts) {
 	const base = "https://search.google.com/search-console";
 	const resource = opts.resource ?? "performance";
@@ -1007,20 +1070,6 @@ function extractMessage(e) {
 function isAbort(e) {
 	return e?.name === "AbortError";
 }
-function dateFilter(r) {
-	return {
-		type: "between",
-		column: "date",
-		from: r.start,
-		to: r.end
-	};
-}
-function andFilter(...filters) {
-	return {
-		type: "and",
-		filters: filters.filter((f) => f != null)
-	};
-}
 const PERIOD_PRESETS = [
 	{
 		value: "7d",
@@ -1276,132 +1325,11 @@ const issueDetails = {
 		fix: "Check individual URLs in Google Search Console's URL Inspection tool for specific reasons. Common causes include quality, duplicate content, or crawl issues."
 	}
 };
-const nuxtSeoTips = {
-	blocked_robots: {
-		modules: ["@nuxtjs/robots", "@nuxtjs/seo"],
-		tip: "Check nuxt.config robots rules and route rules for Disallow:\n\nexport default defineNuxtConfig({\n  robots: { disallow: ['/admin'] },\n  routeRules: {\n    '/secret/**': { robots: false }\n  }\n})"
-	},
-	noindex: {
-		modules: ["@nuxtjs/seo"],
-		tip: "Check for noindex in route rules or page meta:\n\n// nuxt.config.ts\nrouteRules: { '/draft/**': { index: false } }\n\n// pages/draft.vue\ndefinePageMeta({ robots: 'noindex' })"
-	},
-	unknown_to_google: {
-		modules: ["@nuxtjs/sitemap", "@nuxtjs/seo"],
-		tip: "Ensure @nuxtjs/sitemap includes these routes. Dynamic routes need sources:\n\nexport default defineNuxtConfig({\n  sitemap: {\n    sources: ['/api/__sitemap__/urls']\n  }\n})\n\nVerify at /sitemap.xml that these URLs appear."
-	},
-	canonical_mismatch: {
-		modules: ["@nuxtjs/seo"],
-		tip: "@nuxtjs/seo auto-generates canonicals from site.url. Check for conflicts:\n\n// nuxt.config.ts — set your canonical origin\nsite: { url: 'https://example.com' }\n\n// Override per page if needed\nuseHead({ link: [{ rel: 'canonical', href: 'https://example.com/preferred' }] })"
-	},
-	soft_404: {
-		modules: ["@nuxtjs/seo"],
-		tip: "Ensure pages render content server-side, not just client-side. Check for missing data:\n\n// pages/[slug].vue\nconst { data } = await useAsyncData(() => fetchContent(slug))\nif (!data.value)\n  throw createError({ statusCode: 404 }) // Return real 404, not empty page"
-	}
-};
 const severityOrder = [
 	"error",
 	"warning",
 	"info"
 ];
-const investigationStatusConfig = {
-	investigated: {
-		label: "Investigated",
-		icon: "i-lucide-check-circle",
-		color: "success"
-	},
-	fixed: {
-		label: "Fixed",
-		icon: "i-lucide-wrench",
-		color: "success"
-	},
-	false_positive: {
-		label: "False positive",
-		icon: "i-lucide-shield-check",
-		color: "info"
-	},
-	wont_fix: {
-		label: "Won't fix",
-		icon: "i-lucide-ban",
-		color: "neutral"
-	},
-	monitoring: {
-		label: "Monitoring",
-		icon: "i-lucide-eye",
-		color: "warning"
-	}
-};
-const coverageLabels = {
-	"Crawled - currently not indexed": {
-		short: "Crawled, not indexed",
-		color: "text-error"
-	},
-	"Discovered - currently not indexed": {
-		short: "Discovered, not indexed",
-		color: "text-warning"
-	},
-	"Server error (5xx)": {
-		short: "Server error",
-		color: "text-error"
-	},
-	"Not found (404)": {
-		short: "404",
-		color: "text-error"
-	},
-	"Soft 404": {
-		short: "Soft 404",
-		color: "text-error"
-	},
-	"URL is unknown to Google": {
-		short: "Unknown",
-		color: "text-warning"
-	},
-	"Blocked by robots.txt": {
-		short: "Robots blocked",
-		color: "text-warning"
-	},
-	"Blocked due to access forbidden (403)": {
-		short: "Forbidden (403)",
-		color: "text-error"
-	},
-	"Blocked due to unauthorized request (401)": {
-		short: "Unauthorized (401)",
-		color: "text-error"
-	},
-	"Blocked due to other 4xx issue": {
-		short: "Blocked (4xx)",
-		color: "text-error"
-	},
-	"Redirect error": {
-		short: "Redirect error",
-		color: "text-error"
-	},
-	"Page with redirect": {
-		short: "Redirect",
-		color: "text-muted"
-	},
-	"Alternate page with proper canonical tag": {
-		short: "Alternate canonical",
-		color: "text-muted"
-	},
-	"Duplicate without user-selected canonical": {
-		short: "Duplicate, no canonical",
-		color: "text-warning"
-	},
-	"Duplicate, Google chose different canonical than user": {
-		short: "Canonical overridden",
-		color: "text-warning"
-	},
-	"Blocked by page removal tool": {
-		short: "Removal tool",
-		color: "text-muted"
-	}
-};
-function coverageLabel(state) {
-	return coverageLabels[state] || {
-		short: state,
-		color: "text-muted"
-	};
-}
 const issueGroups = [
 	{
 		id: "quick-wins",
@@ -1470,16 +1398,6 @@ const issueGroups = [
 		]
 	}
 ];
-const issueTypeToGroup = Object.fromEntries(issueGroups.flatMap((g) => g.issueTypes.map((t) => [t, g.id])));
-function enrichIssueDetails(modules) {
-	const moduleNames = new Set(modules?.map((m) => m.name) ?? []);
-	const result = { ...issueDetails };
-	for (const [issueType, nuxtTip] of Object.entries(nuxtSeoTips)) if (nuxtTip.modules.some((m) => moduleNames.has(m)) && result[issueType]) result[issueType] = {
-		...result[issueType],
-		fix: `${result[issueType].fix}\n\nNuxt SEO: ${nuxtTip.tip}`
-	};
-	return result;
-}
 function isCustomPeriod(p) {
 	return typeof p === "string" && p.startsWith("custom:");
 }
@@ -2308,9 +2226,6 @@ async function hmacSha256(payload, secret) {
 	}, false, ["sign"]);
 	return crypto.subtle.sign("HMAC", key, encoder.encode(payload));
 }
-function serializeWebhookPayload(payload) {
-	return toPayloadString(payload);
-}
 async function verifyWebhookSignature(payload, signature, secret) {
 	if (!signature) return false;
 	const hex = signatureHex(signature);
@@ -2358,4 +2273,4 @@ function readWebhookHeaders(headers) {
 		signature: headers.signature ?? null
 	};
 }
-export { ARCHETYPE_EXECUTION_CLASS, CANONICAL_WEBHOOK_EVENTS, COMPARE_OPTIONS, COUNTRY_NAMES, CWV_GOOD_CLS, CWV_GOOD_INP, CWV_GOOD_LCP, CWV_POOR_CLS, CWV_POOR_INP, CWV_POOR_LCP, DEFAULT_SEARCH_TYPE, GSC_COLUMN_OPTIONS, GSC_PERIOD_OPTIONS, GSC_PERIOD_OPTIONS_LONG, GSC_STABLE_LATENCY_DAYS, PERIOD_PRESETS, PartnerApiError, SITE_TYPE_BASELINE, VALID_WEBHOOK_EVENTS, WEBHOOK_CONTRACT_VERSION, WEBHOOK_CONTRACT_VERSION_HEADER, WEBHOOK_DELIVERY_HEADER, WEBHOOK_EVENT_HEADER, WEBHOOK_SIGNATURE_HEADER, WEBHOOK_TIMESTAMP_HEADER, analyticsStatusToSyncStatus, andFilter, arbitrarySql, auxCloudOnly, classifyGscError, classifyHealthStage, classifyReachStage, classifySearchConsoleStage, classifySiteTriage, coerceRowMetrics, compareRange, countryName, coverageLabel, coverageLabels, createAnalyticsClient, createPartnerClient, cwvBucket, dateFilter, dateRangeOptionsQuery, defineGscAnalyzer, derivePeerStanding, deriveSiteBaseline, enrichIssueDetails, entityDailySparkline, entityDailyTimeseries, findLifecycleSite, formatPartnerError, getGscUnstableCutoffDate, gscConsoleUrl, investigationStatusConfig, isCustomPeriod, isPartnerError, issueDetails, issueGroups, issueTypeToGroup, lifecycleSiteToSyncStatus, lifecycleSiteToUserSite, multiSeriesStackedDaily, normalizeSiteType, nuxtSeoTips, parseCustomPeriod, parseWebhookPayload, parseWebhookPayloadResult, partnerErrorToException, periodToDateRange, periodToDays, positionFor, reachLivenessRatio, readWebhookHeaders, searchTypeQuery, serializeWebhookPayload, severityOrder, singleRowLookup, siteDailyTimeseries, siteTypeBaseline, siteUrlToHostname, sourceInfoQuery, splitOpportunityTitle, summarizeDailyRows, tablesQuery, toPartnerError, topNBreakdown, truncateQuery, twoDimensionDetail, verifyWebhookSignature, weightedAnonPct, withDefaultSearchType };
+export { CANONICAL_WEBHOOK_EVENTS, COMPARE_OPTIONS, CWV_GOOD_CLS, CWV_GOOD_INP, CWV_GOOD_LCP, CWV_POOR_CLS, CWV_POOR_INP, CWV_POOR_LCP, DEFAULT_SEARCH_TYPE, GSC_COLUMN_OPTIONS, GSC_PERIOD_OPTIONS, GSC_PERIOD_OPTIONS_LONG, GSC_STABLE_LATENCY_DAYS, PERIOD_PRESETS, PartnerApiError, SITE_TYPE_BASELINE, VALID_WEBHOOK_EVENTS, WEBHOOK_CONTRACT_VERSION, WEBHOOK_CONTRACT_VERSION_HEADER, WEBHOOK_DELIVERY_HEADER, WEBHOOK_EVENT_HEADER, WEBHOOK_SIGNATURE_HEADER, WEBHOOK_TIMESTAMP_HEADER, analyticsStatusToSyncStatus, archetypeSeamSupportsQuery, builderStateToArchetype, classifyGscError, classifyHealthStage, classifyReachStage, classifySearchConsoleStage, classifySiteTriage, coerceRowMetrics, compareRange, countryName, createAnalyticsClient, createPartnerClient, cwvBucket, dateRangeOptionsQuery, defineGscAnalyzer, derivePeerStanding, deriveSiteBaseline, extractWireDateRange, findLifecycleSite, getGscUnstableCutoffDate, gscConsoleUrl, isCustomPeriod, issueDetails, issueGroups, lifecycleSiteToSyncStatus, lifecycleSiteToUserSite, normalizeSiteType, parseCustomPeriod, parseWebhookPayload, parseWebhookPayloadResult, partnerErrorToException, periodToDateRange, periodToDays, positionFor, reachLivenessRatio, readWebhookHeaders, searchTypeQuery, severityOrder, siteTypeBaseline, siteUrlToHostname, sourceInfoQuery, summarizeDailyRows, tablesQuery, toPartnerError, truncateQuery, verifyWebhookSignature, weightedAnonPct, withDefaultSearchType };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gscdump/sdk",
   "type": "module",
-  "version": "0.40.2",
+  "version": "1.0.0",
   "description": "Consumer SDK for hosted gscdump.com integrations.",
   "author": {
     "name": "Harlan Wilton",
@@ -26,11 +26,6 @@
       "import": "./dist/index.mjs",
       "default": "./dist/index.mjs"
     },
-    "./query": {
-      "types": "./dist/query.d.mts",
-      "import": "./dist/query.mjs",
-      "default": "./dist/query.mjs"
-    },
     "./v1": {
       "types": "./dist/v1/index.d.mts",
       "import": "./dist/v1/index.mjs",
@@ -43,16 +38,16 @@
     "dist"
   ],
   "engines": {
-    "node": ">=18"
+    "node": ">=22"
   },
   "dependencies": {
     "date-fns": "^4.4.0",
     "ofetch": "^1.5.1",
     "zod": "^4.4.3",
-    "@gscdump/contracts": "0.40.2",
-    "@gscdump/engine": "0.40.2",
-    "gscdump": "0.40.2",
-    "@gscdump/analysis": "0.40.2"
+    "@gscdump/contracts": "^1.0.0",
+    "@gscdump/analysis": "^1.0.0",
+    "@gscdump/engine": "^1.0.0",
+    "gscdump": "^1.0.0"
   },
   "devDependencies": {
     "typescript": "^6.0.3",

package/dist/_chunks/query.d.mts

@@ -1,2 +0,0 @@
-import * as import_gscdump_query from "gscdump/query";
-export { __exportAll, __reExport, query_d_exports };

package/dist/query.d.mts

@@ -1,2 +0,0 @@
-import "./_chunks/query.mjs";
-export * from "gscdump/query";

package/dist/query.mjs

@@ -1,2 +0,0 @@
-export * from "gscdump/query";
-export {};