gscdump 0.0.1 → 0.1.2

package/dist/query/index.d.mts

@@ -0,0 +1,157 @@
+import "ofetch";
+import { indexing_v3 } from "@googleapis/indexing/v3";
+import { searchconsole_v1 } from "@googleapis/searchconsole/v1";
+
+//#region src/core/types.d.ts
+type ApiSite = searchconsole_v1.Schema$WmxSite;
+type ApiSitemap = searchconsole_v1.Schema$WmxSitemap;
+type SearchAnalyticsQuery = searchconsole_v1.Schema$SearchAnalyticsQueryRequest;
+type SearchAnalyticsResponse = searchconsole_v1.Schema$SearchAnalyticsQueryResponse;
+type InspectUrlIndexResponse = searchconsole_v1.Schema$InspectUrlIndexResponse;
+type UrlNotificationMetadata = indexing_v3.Schema$UrlNotificationMetadata;
+type PublishUrlNotificationResponse = indexing_v3.Schema$PublishUrlNotificationResponse;
+//#endregion
+//#region src/core/client.d.ts
+
+interface GoogleSearchConsoleClient {
+  sites: {
+    list: () => Promise<{
+      siteEntry?: ApiSite[];
+    }>;
+  };
+  sitemaps: {
+    list: (siteUrl: string) => Promise<{
+      sitemap?: ApiSitemap[];
+    }>;
+    get: (siteUrl: string, feedpath: string) => Promise<ApiSitemap>;
+    submit: (siteUrl: string, feedpath: string) => Promise<void>;
+    delete: (siteUrl: string, feedpath: string) => Promise<void>;
+  };
+  searchAnalytics: {
+    query: (siteUrl: string, body: SearchAnalyticsQuery) => Promise<SearchAnalyticsResponse>;
+  };
+  urlInspection: {
+    inspect: (siteUrl: string, inspectionUrl: string) => Promise<InspectUrlIndexResponse>;
+  };
+  indexing: {
+    publish: (url: string, type: 'URL_UPDATED' | 'URL_DELETED') => Promise<PublishUrlNotificationResponse>;
+    getMetadata: (url: string) => Promise<UrlNotificationMetadata>;
+  };
+}
+//#endregion
+//#region src/utils/countries.d.ts
+declare const _default: {
+  name: string;
+  'alpha-2': string;
+  'alpha-3': string;
+  'country-code': string;
+}[];
+//#endregion
+//#region src/query/constants.d.ts
+declare const Device: {
+  readonly MOBILE: "MOBILE";
+  readonly DESKTOP: "DESKTOP";
+  readonly TABLET: "TABLET";
+};
+type Device = typeof Device[keyof typeof Device];
+declare const Country: { [K in (typeof _default)[number]["alpha-3"]]: Lowercase<K> };
+type Country = typeof Country[keyof typeof Country];
+//#endregion
+//#region src/query/types.d.ts
+interface DimensionValueMap {
+  query: string;
+  page: string;
+  country: Country;
+  device: Device;
+  searchAppearance: string;
+  date: string;
+}
+type Dimension = keyof DimensionValueMap;
+declare const ColumnBrand: unique symbol;
+interface Column<D extends Dimension> {
+  readonly [ColumnBrand]: D;
+  readonly dimension: D;
+}
+type FilterOperator = 'equals' | 'notEquals' | 'contains' | 'notContains' | 'includingRegex' | 'excludingRegex';
+type DateOperator = 'gte' | 'gt' | 'lte' | 'lt' | 'between';
+interface InternalFilter {
+  dimension: Dimension;
+  operator: FilterOperator | DateOperator;
+  expression: string;
+  expression2?: string;
+}
+declare const FilterBrand: unique symbol;
+interface Filter<C = object> {
+  readonly [FilterBrand]: true;
+  readonly _constraints: C;
+  readonly _filters: InternalFilter[];
+  readonly _groupType?: 'and' | 'or';
+}
+type MergeConstraints<F extends Filter<any>[]> = UnionToIntersection<F[number]['_constraints']>;
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+interface GSCResult<D extends Dimension[], C> {
+  rows: Array<GSCRow<D, C>>;
+}
+type GSCRow<D extends Dimension[], C> = { [K in D[number]]: K extends keyof C ? C[K] : DimensionValueMap[K] } & {
+  clicks: number;
+  impressions: number;
+  ctr: number;
+  position: number;
+};
+interface BuilderState {
+  dimensions: Dimension[];
+  filters: Filter<any>[];
+  siteUrl?: string;
+  rowLimit?: number;
+  startRow?: number;
+}
+//#endregion
+//#region src/query/builder.d.ts
+interface GSCQueryBuilder<D extends Dimension[] = [], C = object> {
+  select: <T extends Dimension[]>(...dims: T) => GSCQueryBuilder<T, C>;
+  where: <F extends Filter<any>>(filter: F) => GSCQueryBuilder<D, C & F['_constraints']>;
+  siteUrl: (url: string) => GSCQueryBuilder<D, C>;
+  limit: (n: number) => GSCQueryBuilder<D, C>;
+  offset: (n: number) => GSCQueryBuilder<D, C>;
+  execute: (client: GoogleSearchConsoleClient) => Promise<GSCResult<D, C>>;
+  toBody: () => SearchAnalyticsQuery;
+  /** Expose internal state for analysis functions to merge with */
+  getState: () => BuilderState;
+}
+declare const gsc: GSCQueryBuilder<[], object>;
+//#endregion
+//#region src/query/columns.d.ts
+declare const page: Column<"page">;
+declare const query: Column<"query">;
+declare const device: Column<"device">;
+declare const country: Column<"country">;
+declare const searchAppearance: Column<"searchAppearance">;
+declare const date: Column<"date">;
+//#endregion
+//#region src/query/operators.d.ts
+declare function eq<D extends Dimension, V extends DimensionValueMap[D]>(column: Column<D>, value: V): Filter<Record<D, V>>;
+declare function 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<D extends Dimension>(column: Column<D>, value: DimensionValueMap[D]): Filter<object>;
+declare function gt<D extends Dimension>(column: Column<D>, value: DimensionValueMap[D]): Filter<object>;
+declare function lte<D extends Dimension>(column: Column<D>, value: DimensionValueMap[D]): Filter<object>;
+declare function lt<D extends Dimension>(column: Column<D>, value: DimensionValueMap[D]): Filter<object>;
+declare function between<D extends Dimension>(column: Column<D>, start: DimensionValueMap[D], end: DimensionValueMap[D]): Filter<object>;
+//#endregion
+//#region src/query/resolver.d.ts
+/**
+ * Extract date range from filters. Used by analysis functions to get the period.
+ */
+declare function extractDateRange(filters: Filter<any>[]): {
+  startDate?: string;
+  endDate?: string;
+};
+//#endregion
+export { type BuilderState, type Column, Country, type Country as CountryType, Device, type Device as DeviceType, type Dimension, type DimensionValueMap, type Filter, type GSCQueryBuilder, type GSCResult, type GSCRow, and, between, contains, country, date, device, eq, extractDateRange, gsc, gt, gte, inArray, like, lt, lte, ne, not, notRegex, or, page, query, regex, searchAppearance };