@gscdump/sdk 1.0.2 → 1.0.4

package/dist/client.d.mts

@@ -0,0 +1,122 @@
+import { AnalysisSourcesOptions, SearchTypeOptions, SourceRangeOptions } from "./hosted-query.mjs";
+import { HostedClientOptions, HostedFetch, HostedFetchOptions, HostedHeaders } from "./_chunks/request.mjs";
+import { AddPartnerTeamMemberParams, BindPartnerSiteTeamParams, BindPartnerTeamCatalogParams, BindPartnerTeamCatalogResponse, BuilderStateWire, BulkRegisterPartnerSitesParams, BulkRegisterPartnerSitesResponse, CreatePartnerTeamParams, DataDetailOptions, DataQueryOptions, DeletePartnerUserResponse, GscAddAndVerifyResponse, 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, IndexingDiagnosticsParams, IndexingInspectRateLimited, IndexingInspectRequest, IndexingInspectResponse, IndexingUrlsParams, PartnerLifecycleResponse, PartnerSitemapAction, PartnerSitemapActionResponse, RegisterPartnerSiteParams, RegisterPartnerUserParams, UpdatePartnerUserTokensParams } from "@gscdump/contracts";
+type PartnerFetch = HostedFetch;
+type PartnerHeaders = HostedHeaders;
+type PartnerFetchOptions = HostedFetchOptions;
+interface PartnerClientOptions extends HostedClientOptions {
+  /**
+   * Origin API base. Use `/api` for same-origin Nitro routes, or pass a full
+   * remote origin base from the host app. The client has no baked-in origin.
+   */
+  apiBase?: string;
+  /** Convenience auth hook. Equivalent to supplying `headers: { 'x-api-key': apiKey }`. */
+  apiKey?: string;
+  /** Any ofetch-compatible instance: global `$fetch`, `useGscFetch()`, or a custom test fake. */
+  fetch?: PartnerFetch;
+  /** Static or lazy headers. Lazy headers are resolved on every operation. */
+  headers?: PartnerHeaders;
+  /** Validate request payloads and response bodies with exported Zod schemas. */
+  validate?: boolean | 'request' | 'response';
+}
+/** 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;
+export { PartnerClient, PartnerClientOptions, PartnerFetch, PartnerFetchOptions, PartnerHeaders, createPartnerClient };

package/dist/client.mjs

@@ -0,0 +1,365 @@
+import { dataDetailQuery, dataQuery, indexingDiagnosticsQuery, indexingUrlsQuery, pageTrendQuery, queryTrendQuery, tablesQuery } from "./hosted-query.mjs";
+import { PartnerApiError, partnerErrorToException } from "./errors.mjs";
+import { createHostedRequester } from "./_chunks/request.mjs";
+import { findLifecycleSite, lifecycleSiteToSyncStatus } from "./lifecycle.mjs";
+import { err, ok, unwrapResult } from "gscdump/result";
+import { partnerEndpoints } from "@gscdump/contracts/partner";
+const endpoints = partnerEndpoints;
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function createPartnerClient(options = {}) {
+	const { request, requestResult, shouldValidate } = createHostedRequester(options, { apiBase: "/api" });
+	async function waitForUserReadyResult(userId, waitOptions = {}) {
+		const attempts = waitOptions.attempts ?? 12;
+		const intervalMs = waitOptions.intervalMs ?? 1e3;
+		let latest = null;
+		for (let attempt = 0; attempt < attempts; attempt++) {
+			const result = await requestResult(endpoints.getUserStatus.path(userId), { method: endpoints.getUserStatus.method });
+			if (!result.ok) return result;
+			latest = result.value;
+			if (latest.status === "ready") return ok(latest);
+			if (attempt < attempts - 1) await sleep(intervalMs);
+		}
+		return err(new PartnerApiError({
+			kind: "provisioning",
+			statusCode: 409,
+			message: "gscdump user database is still provisioning",
+			data: latest
+		}));
+	}
+	function waitForUserReadyToException(error) {
+		const e = new Error(error.message);
+		e.data = error.data;
+		return e;
+	}
+	async function waitForUserLifecycleReadyResult(userId, waitOptions = {}) {
+		const attempts = waitOptions.attempts ?? 12;
+		const intervalMs = waitOptions.intervalMs ?? 1e3;
+		let latest = null;
+		for (let attempt = 0; attempt < attempts; attempt++) {
+			const result = await requestResult(endpoints.getUserLifecycle.path(userId), { method: endpoints.getUserLifecycle.method });
+			if (!result.ok) return result;
+			latest = result.value;
+			const status = latest.account.status;
+			if (status === "ready") return ok(latest);
+			if (status === "refresh_missing" || status === "scope_missing" || status === "reauth_required") return err(new PartnerApiError({
+				kind: "auth",
+				statusCode: 401,
+				message: "Google Search Console authorization must be refreshed",
+				data: latest.account
+			}));
+			if (status === "disconnected" || status === "oauth_received") return err(new PartnerApiError({
+				kind: "provisioning",
+				statusCode: 409,
+				message: "gscdump user is not fully connected",
+				data: latest.account
+			}));
+			if (attempt < attempts - 1) await sleep(intervalMs);
+		}
+		return err(new PartnerApiError({
+			kind: "provisioning",
+			statusCode: 409,
+			message: "gscdump user database is still provisioning",
+			data: latest
+		}));
+	}
+	async function getSiteSyncStatusResult(siteId, userId) {
+		if (!userId) return requestResult(endpoints.getSyncStatus.path(siteId), { method: endpoints.getSyncStatus.method });
+		const lifecycle = await requestResult(endpoints.getUserLifecycle.path(userId), { method: endpoints.getUserLifecycle.method });
+		if (!lifecycle.ok) return lifecycle;
+		const site = findLifecycleSite(lifecycle.value, siteId);
+		if (!site) return err(new PartnerApiError({
+			kind: "not-found",
+			statusCode: 404,
+			message: "gscdump lifecycle site not found",
+			data: {
+				siteId,
+				userId
+			}
+		}));
+		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;
+			return request(endpoints.registerUser.path, {
+				method: endpoints.registerUser.method,
+				body
+			}, endpoints.registerUser.response);
+		},
+		updateUserTokens(userId, params) {
+			const body = shouldValidate("request") ? endpoints.updateUserTokens.body.parse(params) : params;
+			return request(endpoints.updateUserTokens.path(userId), {
+				method: endpoints.updateUserTokens.method,
+				body
+			}, endpoints.updateUserTokens.response);
+		},
+		getUserStatus(userId) {
+			return request(endpoints.getUserStatus.path(userId), { method: endpoints.getUserStatus.method }, endpoints.getUserStatus.response);
+		},
+		getUserLifecycle(userId) {
+			return request(endpoints.getUserLifecycle.path(userId), { method: endpoints.getUserLifecycle.method }, endpoints.getUserLifecycle.response);
+		},
+		async waitForUserReady(userId, waitOptions = {}) {
+			return unwrapResult(await waitForUserReadyResult(userId, waitOptions), waitForUserReadyToException);
+		},
+		async waitForUserLifecycleReady(userId, waitOptions = {}) {
+			return unwrapResult(await waitForUserLifecycleReadyResult(userId, waitOptions), partnerErrorToException);
+		},
+		getUserSites(userId) {
+			return request(endpoints.getUserSites.path(userId), { method: endpoints.getUserSites.method }, endpoints.getUserSites.response);
+		},
+		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, {
+				method: endpoints.registerSite.method,
+				body
+			}, endpoints.registerSite.response);
+		},
+		bulkRegisterSites(params) {
+			const body = shouldValidate("request") ? endpoints.bulkRegisterSites.body.parse(params) : params;
+			return request(endpoints.bulkRegisterSites.path, {
+				method: endpoints.bulkRegisterSites.method,
+				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);
+		},
+		deleteSite(siteId) {
+			return request(endpoints.deleteSite.path(siteId), { method: endpoints.deleteSite.method });
+		},
+		getAnalysisSources(siteId, tables, options) {
+			return request(endpoints.getAnalysisSources.path(siteId), {
+				method: endpoints.getAnalysisSources.method,
+				query: tablesQuery(tables, options)
+			}, endpoints.getAnalysisSources.response);
+		},
+		async getSiteSyncStatus(siteId, userId) {
+			return unwrapResult(await getSiteSyncStatusResult(siteId, userId), partnerErrorToException);
+		},
+		getData(siteId, state, queryOptions) {
+			if (shouldValidate("request")) {
+				endpoints.getData.state.parse(state);
+				endpoints.getData.options.parse(queryOptions);
+			}
+			return request(endpoints.getData.path(siteId), {
+				method: endpoints.getData.method,
+				query: dataQuery(state, queryOptions)
+			}, endpoints.getData.response);
+		},
+		getDataDetail(siteId, state, queryOptions) {
+			if (shouldValidate("request")) {
+				endpoints.getDataDetail.state.parse(state);
+				endpoints.getDataDetail.options.parse(queryOptions);
+			}
+			return request(endpoints.getDataDetail.path(siteId), {
+				method: endpoints.getDataDetail.method,
+				query: dataDetailQuery(state, queryOptions)
+			}, endpoints.getDataDetail.response);
+		},
+		getSitemaps(siteId) {
+			return request(endpoints.getSitemaps.path(siteId), { method: endpoints.getSitemaps.method }, endpoints.getSitemaps.response);
+		},
+		getSitemapChanges(siteId, days = 28) {
+			return request(endpoints.getSitemapChanges.path(siteId), {
+				method: endpoints.getSitemapChanges.method,
+				query: { days }
+			}, endpoints.getSitemapChanges.response);
+		},
+		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);
+		},
+		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), {
+				method: endpoints.getIndexing.method,
+				query: { days }
+			}, endpoints.getIndexing.response);
+		},
+		getIndexingUrls(siteId, params = {}) {
+			const parsed = shouldValidate("request") ? endpoints.getIndexingUrls.query.parse(params) : params;
+			return request(endpoints.getIndexingUrls.path(siteId), {
+				method: endpoints.getIndexingUrls.method,
+				query: indexingUrlsQuery(parsed)
+			}, endpoints.getIndexingUrls.response);
+		},
+		getIndexingDiagnostics(siteId, params = {}) {
+			const parsed = shouldValidate("request") ? endpoints.getIndexingDiagnostics.query.parse(params) : params;
+			return request(endpoints.getIndexingDiagnostics.path(siteId), {
+				method: endpoints.getIndexingDiagnostics.method,
+				query: indexingDiagnosticsQuery(parsed)
+			}, endpoints.getIndexingDiagnostics.response);
+		},
+		requestIndexingInspect(siteId, body) {
+			const parsed = shouldValidate("request") ? endpoints.requestIndexingInspect.body.parse(body) : body;
+			return request(endpoints.requestIndexingInspect.path(siteId), {
+				method: endpoints.requestIndexingInspect.method,
+				body: parsed
+			}, endpoints.requestIndexingInspect.response);
+		},
+		getUserSettings() {
+			return request(endpoints.getUserSettings.path, { method: endpoints.getUserSettings.method }, endpoints.getUserSettings.response);
+		},
+		patchUserSettings(body) {
+			const parsed = shouldValidate("request") ? endpoints.patchUserSettings.body.parse(body) : body;
+			return request(endpoints.patchUserSettings.path, {
+				method: endpoints.patchUserSettings.method,
+				body: parsed
+			}, endpoints.patchUserSettings.response);
+		},
+		recoverPermission(siteId) {
+			return request(endpoints.recoverPermission.path(siteId), { method: endpoints.recoverPermission.method }, endpoints.recoverPermission.response);
+		},
+		getTopAssociation(siteId, params) {
+			const query = shouldValidate("request") ? endpoints.getTopAssociation.query.parse(params) : params;
+			return request(endpoints.getTopAssociation.path(siteId), {
+				method: endpoints.getTopAssociation.method,
+				query
+			}, endpoints.getTopAssociation.response);
+		},
+		getKeywordSparklines(siteId, params) {
+			const withSearchType = {
+				...params,
+				searchType: params.searchType ?? "web"
+			};
+			const body = shouldValidate("request") ? endpoints.getKeywordSparklines.body.parse(withSearchType) : withSearchType;
+			return request(endpoints.getKeywordSparklines.path(siteId), {
+				method: endpoints.getKeywordSparklines.method,
+				body,
+				dedupe: true
+			}, endpoints.getKeywordSparklines.response);
+		},
+		getQueryTrend(siteId, params) {
+			const query = shouldValidate("request") ? endpoints.getQueryTrend.query.parse(params) : params;
+			return request(endpoints.getQueryTrend.path(siteId), {
+				method: endpoints.getQueryTrend.method,
+				query: queryTrendQuery(query)
+			}, endpoints.getQueryTrend.response);
+		},
+		getPageTrend(siteId, params) {
+			const query = shouldValidate("request") ? endpoints.getPageTrend.query.parse(params) : params;
+			return request(endpoints.getPageTrend.path(siteId), {
+				method: endpoints.getPageTrend.method,
+				query: pageTrendQuery(query)
+			}, endpoints.getPageTrend.response);
+		},
+		getCanonicalMismatches(siteId) {
+			return request(endpoints.getCanonicalMismatches.path(siteId), { method: endpoints.getCanonicalMismatches.method }, endpoints.getCanonicalMismatches.response);
+		},
+		getIndexPercent(siteId, params = {}) {
+			const query = shouldValidate("request") ? endpoints.getIndexPercent.query.parse(params) : params;
+			return request(endpoints.getIndexPercent.path(siteId), {
+				method: endpoints.getIndexPercent.method,
+				query
+			}, endpoints.getIndexPercent.response);
+		},
+		createTeam(params) {
+			const body = shouldValidate("request") ? endpoints.createTeam.body.parse(params) : params;
+			return request(endpoints.createTeam.path, {
+				method: endpoints.createTeam.method,
+				body
+			}, 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
+			}, endpoints.renameTeam.response);
+		},
+		deleteTeam(teamId) {
+			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);
+		},
+		addTeamMember(teamId, params) {
+			const body = shouldValidate("request") ? endpoints.addTeamMember.body.parse(params) : params;
+			return request(endpoints.addTeamMember.path(teamId), {
+				method: endpoints.addTeamMember.method,
+				body
+			}, 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
+			}, endpoints.updateTeamMemberRole.response);
+		},
+		removeTeamMember(teamId, userId) {
+			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;
+			return request(endpoints.bindSiteToTeam.path(userId, siteId), {
+				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);
+		}
+	};
+}
+export { createPartnerClient };

package/dist/country-names.d.mts

@@ -0,0 +1,2 @@
+declare const countryName: (code: string) => string;
+export { countryName };

package/dist/country-names.mjs

@@ -0,0 +1,56 @@
+const COUNTRY_NAMES = {
+	US: "United States",
+	GB: "United Kingdom",
+	DE: "Germany",
+	FR: "France",
+	CA: "Canada",
+	AU: "Australia",
+	IN: "India",
+	BR: "Brazil",
+	JP: "Japan",
+	IT: "Italy",
+	ES: "Spain",
+	NL: "Netherlands",
+	SE: "Sweden",
+	CH: "Switzerland",
+	MX: "Mexico",
+	KR: "South Korea",
+	RU: "Russia",
+	PL: "Poland",
+	BE: "Belgium",
+	AT: "Austria",
+	NO: "Norway",
+	DK: "Denmark",
+	FI: "Finland",
+	PT: "Portugal",
+	IE: "Ireland",
+	NZ: "New Zealand",
+	SG: "Singapore",
+	HK: "Hong Kong",
+	TW: "Taiwan",
+	IL: "Israel",
+	ZA: "South Africa",
+	AR: "Argentina",
+	CL: "Chile",
+	CO: "Colombia",
+	TH: "Thailand",
+	PH: "Philippines",
+	MY: "Malaysia",
+	ID: "Indonesia",
+	VN: "Vietnam",
+	TR: "Turkey",
+	CZ: "Czech Republic",
+	RO: "Romania",
+	HU: "Hungary",
+	GR: "Greece",
+	UA: "Ukraine",
+	EG: "Egypt",
+	NG: "Nigeria",
+	KE: "Kenya",
+	PK: "Pakistan",
+	BD: "Bangladesh",
+	AE: "United Arab Emirates",
+	SA: "Saudi Arabia"
+};
+const countryName = (code) => COUNTRY_NAMES[code] || code;
+export { countryName };

package/dist/cwv-thresholds.d.mts

@@ -0,0 +1,13 @@
+declare const CWV_GOOD_LCP = 2500;
+declare const CWV_POOR_LCP = 4000;
+declare const CWV_GOOD_INP = 200;
+declare const CWV_POOR_INP = 500;
+declare const CWV_GOOD_CLS = 0.1;
+declare const CWV_POOR_CLS = 0.25;
+type CwvBucket = 'good' | 'ni' | 'poor';
+declare function cwvBucket(metric: 'lcp' | 'inp' | 'cls', v: number): CwvBucket;
+/** Trim long query strings for table cells / chart tooltips. */
+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;
+export { CWV_GOOD_CLS, CWV_GOOD_INP, CWV_GOOD_LCP, CWV_POOR_CLS, CWV_POOR_INP, CWV_POOR_LCP, CwvBucket, cwvBucket, siteUrlToHostname, truncateQuery };

package/dist/cwv-thresholds.mjs

@@ -0,0 +1,23 @@
+const CWV_GOOD_LCP = 2500;
+const CWV_POOR_LCP = 4e3;
+const CWV_GOOD_INP = 200;
+const CWV_POOR_INP = 500;
+const CWV_GOOD_CLS = .1;
+const CWV_POOR_CLS = .25;
+function cwvBucket(metric, v) {
+	if (metric === "lcp") return v <= 2500 ? "good" : v <= 4e3 ? "ni" : "poor";
+	if (metric === "inp") return v <= 200 ? "good" : v <= 500 ? "ni" : "poor";
+	return v <= .1 ? "good" : v <= .25 ? "ni" : "poor";
+}
+function truncateQuery(q, max = 48) {
+	return q.length > max ? `${q.slice(0, max - 1)}…` : q;
+}
+function siteUrlToHostname(url) {
+	if (!url) return void 0;
+	try {
+		return new URL(url.startsWith("http") ? url : `https://${url}`).hostname;
+	} catch {
+		return;
+	}
+}
+export { CWV_GOOD_CLS, CWV_GOOD_INP, CWV_GOOD_LCP, CWV_POOR_CLS, CWV_POOR_INP, CWV_POOR_LCP, cwvBucket, siteUrlToHostname, truncateQuery };

package/dist/errors.d.mts

@@ -0,0 +1,2 @@
+import { PartnerApiError, PartnerErrorInfo, PartnerErrorKind, partnerErrorToException, toPartnerError } from "./_chunks/errors.mjs";
+export { PartnerApiError, PartnerErrorInfo, PartnerErrorKind, partnerErrorToException, toPartnerError };

package/dist/errors.mjs

@@ -0,0 +1,47 @@
+var PartnerApiError = class extends Error {
+	kind;
+	statusCode;
+	data;
+	constructor(info) {
+		super(info.message);
+		this.name = "PartnerApiError";
+		this.kind = info.kind;
+		this.statusCode = info.statusCode;
+		this.data = info.data;
+	}
+};
+function statusOf(error) {
+	const rec = error;
+	return rec.statusCode ?? rec.status ?? rec.response?.status;
+}
+function messageOf(error) {
+	const rec = error;
+	return rec.data?.message ?? rec.data?.statusMessage ?? rec.message ?? rec.statusMessage ?? String(error);
+}
+function kindOf(status, message) {
+	if (status === 401 || status === 403) return "auth";
+	if (status === 404) return "not-found";
+	if (status === 409 || /provision/i.test(message)) return "provisioning";
+	if (status === 429) return "rate-limit";
+	if (status === 400 || status === 422) return "validation";
+	if (/permission|reauth|access/i.test(message)) return "permission";
+	if (status && status >= 500) return "server";
+	if (!status) return "network";
+	return "unknown";
+}
+function toPartnerError(error) {
+	if (error instanceof PartnerApiError) return error;
+	const statusCode = statusOf(error);
+	const message = messageOf(error);
+	const data = error?.data;
+	return new PartnerApiError({
+		kind: kindOf(statusCode, message),
+		statusCode,
+		message,
+		data
+	});
+}
+function partnerErrorToException(error) {
+	return error;
+}
+export { PartnerApiError, partnerErrorToException, toPartnerError };

package/dist/gsc-console-url.d.mts

@@ -0,0 +1,12 @@
+interface GscConsoleUrlOpts {
+  /** The GSC property — either `sc-domain:example.com` or a URL-prefix. */
+  siteLabel: string;
+  /** Optional page to open Performance drilldown for. */
+  page?: string;
+  /** Optional query filter. */
+  query?: string;
+  /** Resource: `performance`, `url-inspection`, `sitemaps`, … */
+  resource?: 'performance' | 'url-inspection' | 'sitemaps' | 'index';
+}
+declare function gscConsoleUrl(opts: GscConsoleUrlOpts): string;
+export { GscConsoleUrlOpts, gscConsoleUrl };

package/dist/gsc-console-url.mjs

@@ -0,0 +1,15 @@
+function gscConsoleUrl(opts) {
+	const base = "https://search.google.com/search-console";
+	const resource = opts.resource ?? "performance";
+	const params = new URLSearchParams();
+	const siteLabel = /^(?:https?:|sc-domain:)/.test(opts.siteLabel) ? opts.siteLabel : `sc-domain:${opts.siteLabel}`;
+	params.set("resource_id", siteLabel);
+	if (resource === "url-inspection") {
+		if (opts.page) params.set("id", opts.page);
+	} else {
+		if (opts.page) params.set("page", `*${opts.page}`);
+		if (opts.query) params.set("query", `*${opts.query}`);
+	}
+	return `${base}${resource === "performance" ? "/performance/search-analytics" : resource === "url-inspection" ? "/inspect" : resource === "sitemaps" ? "/sitemaps" : "/index"}?${params.toString()}`;
+}
+export { gscConsoleUrl };