@gscdump/sdk 0.11.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Harlan Wilton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,72 @@
+# @gscdump/sdk
+
+Consumer SDK for hosted gscdump.com integrations.
+
+This package is for partner applications that consume gscdump.com APIs,
+webhooks, and realtime events. Callers inject the HTTP transport and auth they
+want to use; route construction stays inside the hosted adapter.
+
+```ts
+import { createGscdumpClient } from '@gscdump/sdk'
+
+const gscdump = createGscdumpClient({
+  apiBase: 'https://example.com/api',
+  apiKey: process.env.GSCDUMP_API_KEY,
+  fetch: $fetch,
+})
+
+const { sites } = await gscdump.getUserSites(userId)
+```
+
+## Scope
+
+- Partner user lifecycle
+- Partner site lifecycle
+- Data/detail queries
+- Analysis presets
+- Sitemap and indexing reads
+- Webhook receiver contracts and HMAC verification helpers
+- Shared request/response types re-exported from `@gscdump/contracts`
+
+Analyzer Source dispatch, browser DuckDB-WASM boot, R2 parquet attach, and
+Nuxt composables remain in `@gscdump/nuxt-analytics`. Nuxt apps should install
+`@gscdump/nuxt-analytics` for dashboard reads; that layer uses
+`createAnalyticsClient()` internally.
+
+## Boundary
+
+`@gscdump/sdk` is a consumer SDK. It must not own gscdump.com producer
+behavior.
+
+Belongs here:
+
+- request/response types and schemas for partner apps
+- route builders and pluggable HTTP clients
+- websocket client and event schemas
+- webhook header constants, event schemas, parsing, normalization, and signature
+  verification for receivers
+
+Does not belong here:
+
+- deciding when gscdump.com emits webhooks
+- queueing, retries, backoff, idempotency, or activity logging
+- resolving public user/site IDs from gscdump.com storage
+- generating or storing production webhook secrets
+- creating production webhook delivery IDs or envelopes
+- partner subscription filtering for outgoing deliveries
+
+## Webhooks
+
+`@gscdump/contracts` owns the webhook payload schema and event constants.
+`@gscdump/sdk` provides receiver-side helpers to parse the payload, verify the
+signature, and normalize event names. gscdump.com owns webhook production and
+delivery.
+
+```ts
+import { parseWebhookPayload } from '@gscdump/sdk'
+
+const envelope = await parseWebhookPayload(rawJson, {
+  secret: webhookSecret,
+  signature: request.headers.get('x-gscdump-signature'),
+})
+```

package/dist/index.d.mts

@@ -0,0 +1,113 @@
+import { AddPartnerTeamMemberParams, AnalyticsClient, AnalyticsClient as AnalyticsClient$1, BackfillRange, BackfillResponse, BindPartnerSiteTeamParams, BuilderState, BulkRegisterPartnerSiteResult, BulkRegisterPartnerSitesParams, BulkRegisterPartnerSitesResponse, CANONICAL_WEBHOOK_EVENTS, CanonicalWebhookEventType, CanonicalWebhookEventType as CanonicalWebhookEventType$1, CreatePartnerTeamParams, CreateWebhookEnvelopeOptions, DataDetailOptions, DataQueryOptions, DeletePartnerUserResponse, GscComparisonFilter, GscdumpAnalysisParams, GscdumpAnalysisPreset, GscdumpAnalysisResponse, GscdumpAnalysisSourcesResponse, GscdumpAvailableSite, GscdumpCanonicalMismatchesResponse, GscdumpDataDetailResponse, GscdumpDataResponse, GscdumpDataRow, GscdumpDateRangeParams, GscdumpIndexPercentResponse, GscdumpIndexingDiagnosticsResponse, GscdumpIndexingResponse, GscdumpIndexingUrlStatus, GscdumpIndexingUrlsResponse, GscdumpKeywordSparklinesParams, GscdumpKeywordSparklinesResponse, GscdumpMeta, GscdumpPermissionRecovery, GscdumpQueryTrendParams, GscdumpQueryTrendResponse, GscdumpSiteRegistration, GscdumpSitemap, GscdumpSitemapChangesResponse, GscdumpSitemapHistory, GscdumpSitemapsResponse, GscdumpSyncStatusResponse, GscdumpTeamMemberRow, GscdumpTeamRow, GscdumpTopAssociationParams, GscdumpTopAssociationResponse, GscdumpTotals, GscdumpUserRegistration, GscdumpUserSettings, GscdumpUserSite, GscdumpUserStatus, GscdumpUserTokenUpdate, IndexingUrlsParams, InspectionHistoryResponse, InspectionIndex, LEGACY_WEBHOOK_EVENTS, LegacyWebhookEventType, PartnerClient, PartnerClient as PartnerClient$1, PartnerLifecycleAccount, PartnerLifecycleResponse, PartnerLifecycleSite, PartnerRealtimeEvent, PartnerRealtimeEvent as PartnerRealtimeEvent$1, PartnerRealtimeEventType, PartnerRealtimeMessage, PartnerRealtimeMessage as PartnerRealtimeMessage$1, PartnerWebhookData, PartnerWebhookHeaders, PartnerWebhookHeaders as PartnerWebhookHeaders$1, RealtimeAuthFailedEvent, RealtimeAuthRequiredMessage, RealtimeConnectedMessage, RealtimeEnrichmentCompleteEvent, RealtimeErrorMessage, RealtimeJobFailedEvent, RealtimeNeedsReauthEvent, RealtimePongMessage, RealtimeSiteAddedEvent, RealtimeSiteRemovedEvent, RealtimeSubscribedMessage, RealtimeSyncCompleteEvent, RealtimeSyncFailedEvent, RealtimeSyncJobCompleteEvent, RealtimeSyncProgressEvent, RealtimeSyncSiteCompleteEvent, RegisterPartnerSiteParams, RegisterPartnerUserParams, RollupEnvelope, UpdatePartnerUserTokensParams, VALID_WEBHOOK_EVENTS, WEBHOOK_CONTRACT_VERSION, WEBHOOK_CONTRACT_VERSION_HEADER, WEBHOOK_DELIVERY_HEADER, WEBHOOK_EVENT_ALIASES, WEBHOOK_EVENT_HEADER, WEBHOOK_SIGNATURE_HEADER, WEBHOOK_TIMESTAMP_HEADER, WebhookEnvelope, WebhookEnvelope as WebhookEnvelope$1, WebhookEventType, WebhookEventType as WebhookEventType$1, WhoamiResponse } from "@gscdump/contracts";
+export * from "@gscdump/contracts";
+type PartnerFetch = <T = unknown>(request: string, options?: PartnerFetchOptions) => Promise<T>;
+type PartnerHeaders = HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
+interface PartnerFetchOptions {
+  method?: string;
+  headers?: HeadersInit;
+  query?: Record<string, unknown>;
+  body?: unknown;
+  [key: string]: unknown;
+}
+interface PartnerClientOptions {
+  /**
+   * 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';
+}
+declare function createPartnerClient(options?: PartnerClientOptions): PartnerClient$1;
+declare const createGscdumpClient: typeof createPartnerClient;
+type AnalyticsFetch = PartnerFetch;
+type AnalyticsHeaders = PartnerHeaders;
+type AnalyticsFetchOptions = PartnerFetchOptions;
+interface AnalyticsClientOptions {
+  apiBase?: string;
+  fetch?: AnalyticsFetch;
+  headers?: AnalyticsHeaders;
+  validate?: boolean | 'request' | 'response';
+}
+declare function createAnalyticsClient(options?: AnalyticsClientOptions): AnalyticsClient$1;
+type PartnerErrorKind = 'auth' | 'rate-limit' | 'provisioning' | 'permission' | 'network' | 'validation' | 'not-found' | 'server' | 'unknown';
+interface PartnerErrorInfo {
+  kind: PartnerErrorKind;
+  statusCode?: number;
+  message: string;
+  data?: unknown;
+}
+declare class PartnerApiError extends Error {
+  readonly kind: PartnerErrorKind;
+  readonly statusCode?: number;
+  readonly data?: unknown;
+  constructor(info: PartnerErrorInfo);
+}
+declare function toPartnerError(error: unknown): PartnerApiError;
+declare function toCanonicalWebhookEvent(event: WebhookEventType$1): CanonicalWebhookEventType$1;
+declare function serializeWebhookPayload(payload: string | object): string;
+declare function verifyWebhookSignature(payload: string | object, signature: string | null | undefined, secret: string): Promise<boolean>;
+declare function parseWebhookPayload<TData extends Record<string, unknown> = Record<string, unknown>>(payload: string | object, options?: {
+  secret?: string;
+  signature?: string | null;
+  headers?: PartnerWebhookHeaders$1 | Headers;
+  validateSignature?: boolean;
+}): Promise<WebhookEnvelope$1<TData>>;
+declare function readWebhookHeaders(headers: Headers | PartnerWebhookHeaders$1 | null | undefined): Required<PartnerWebhookHeaders$1>;
+type PartnerRealtimeScope = 'partner' | 'user';
+type PartnerRealtimeStatus = 'idle' | 'connecting' | 'open' | 'authenticated' | 'closed' | 'error';
+type PartnerRealtimeHandler<T> = (value: T) => void;
+interface PartnerWebSocketLike {
+  readyState: number;
+  onopen: ((event: unknown) => void) | null;
+  onmessage: ((event: {
+    data: unknown;
+  }) => void) | null;
+  onerror: ((event: unknown) => void) | null;
+  onclose: ((event: unknown) => void) | null;
+  send: (data: string) => void;
+  close: (code?: number, reason?: string) => void;
+}
+interface PartnerWebSocketConstructor {
+  new (url: string, protocols?: string | string[]): PartnerWebSocketLike;
+}
+interface PartnerRealtimeOptions {
+  /**
+   * HTTP API base used only to derive a same-origin websocket base when `wsBase`
+   * is omitted. Prefer passing `wsBase` when the websocket origin differs.
+   */
+  apiBase?: string;
+  /** WebSocket origin base, for example `wss://origin.example`. */
+  wsBase?: string;
+  /** Partner or user API key sent in the first auth message. */
+  apiKey: string;
+  /** `/ws/partner` or `/ws/user`. User scope supports partner key + user id. */
+  scope?: PartnerRealtimeScope;
+  /** Required by the hosted `/ws/user` route when authenticating with a partner API key. */
+  userId?: number | string;
+  /** Optional initial site filter sent after authentication succeeds. */
+  siteIds?: string[];
+  protocols?: string | string[];
+  WebSocket?: PartnerWebSocketConstructor;
+}
+interface PartnerRealtimeClient {
+  readonly status: PartnerRealtimeStatus;
+  readonly socket: PartnerWebSocketLike | null;
+  connect: () => PartnerWebSocketLike;
+  close: (code?: number, reason?: string) => void;
+  ping: () => void;
+  subscribe: (siteIds: string[]) => void;
+  onStatus: (handler: PartnerRealtimeHandler<PartnerRealtimeStatus>) => () => void;
+  onMessage: (handler: PartnerRealtimeHandler<PartnerRealtimeMessage$1>) => () => void;
+  onEvent: (handler: PartnerRealtimeHandler<PartnerRealtimeEvent$1>) => () => void;
+  onError: (handler: PartnerRealtimeHandler<unknown>) => () => void;
+}
+declare function createPartnerRealtimeClient(options: PartnerRealtimeOptions): PartnerRealtimeClient;
+declare const createGscdumpRealtimeClient: typeof createPartnerRealtimeClient;
+export { type AddPartnerTeamMemberParams, type AnalyticsClient, type AnalyticsClientOptions, type AnalyticsFetch, type AnalyticsFetchOptions, type AnalyticsHeaders, type BackfillRange, type BackfillResponse, type BindPartnerSiteTeamParams, type BuilderState, type BulkRegisterPartnerSiteResult, type BulkRegisterPartnerSitesParams, type BulkRegisterPartnerSitesResponse, CANONICAL_WEBHOOK_EVENTS, type CanonicalWebhookEventType, type CreatePartnerTeamParams, type CreateWebhookEnvelopeOptions, type DataDetailOptions, type DataQueryOptions, type DeletePartnerUserResponse, type GscComparisonFilter, 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 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 IndexingUrlsParams, type InspectionHistoryResponse, type InspectionIndex, LEGACY_WEBHOOK_EVENTS, type LegacyWebhookEventType, PartnerApiError, type PartnerClient, type PartnerClientOptions, type PartnerErrorInfo, type PartnerErrorKind, type PartnerFetch, type PartnerFetchOptions, type PartnerHeaders, type PartnerLifecycleAccount, type PartnerLifecycleResponse, type PartnerLifecycleSite, type PartnerRealtimeClient, type PartnerRealtimeEvent, type PartnerRealtimeEventType, type PartnerRealtimeHandler, type PartnerRealtimeMessage, type PartnerRealtimeOptions, type PartnerRealtimeScope, type PartnerRealtimeStatus, type PartnerWebSocketConstructor, type PartnerWebSocketLike, type PartnerWebhookData, type PartnerWebhookHeaders, type RealtimeAuthFailedEvent, type RealtimeAuthRequiredMessage, type RealtimeConnectedMessage, type RealtimeEnrichmentCompleteEvent, type RealtimeErrorMessage, type RealtimeJobFailedEvent, type RealtimeNeedsReauthEvent, type RealtimePongMessage, type RealtimeSiteAddedEvent, type RealtimeSiteRemovedEvent, type RealtimeSubscribedMessage, type RealtimeSyncCompleteEvent, type RealtimeSyncFailedEvent, type RealtimeSyncJobCompleteEvent, type RealtimeSyncProgressEvent, type RealtimeSyncSiteCompleteEvent, type RegisterPartnerSiteParams, type RegisterPartnerUserParams, type RollupEnvelope, type UpdatePartnerUserTokensParams, VALID_WEBHOOK_EVENTS, WEBHOOK_CONTRACT_VERSION, WEBHOOK_CONTRACT_VERSION_HEADER, WEBHOOK_DELIVERY_HEADER, WEBHOOK_EVENT_ALIASES, WEBHOOK_EVENT_HEADER, WEBHOOK_SIGNATURE_HEADER, WEBHOOK_TIMESTAMP_HEADER, type WebhookEnvelope, type WebhookEventType, type WhoamiResponse, createAnalyticsClient, createGscdumpClient, createGscdumpRealtimeClient, createPartnerClient, createPartnerRealtimeClient, parseWebhookPayload, readWebhookHeaders, serializeWebhookPayload, toCanonicalWebhookEvent, toPartnerError, verifyWebhookSignature };

package/dist/index.mjs

@@ -0,0 +1,684 @@
+import { ofetch } from "ofetch";
+import { CANONICAL_WEBHOOK_EVENTS, LEGACY_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_ALIASES, WEBHOOK_EVENT_ALIASES as WEBHOOK_EVENT_ALIASES$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, analyticsRoutes, partnerEndpointSchemas, partnerRoutes, partnerWebhookEnvelopeSchema } from "@gscdump/contracts";
+export * from "@gscdump/contracts";
+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
+	});
+}
+const TRAILING_SLASH_RE$2 = /\/+$/;
+const LEADING_SLASH_RE$1 = /^\/+/;
+function trimApiBase$1(apiBase) {
+	return (apiBase ?? "/api").replace(TRAILING_SLASH_RE$2, "");
+}
+function buildPath$1(apiBase, path) {
+	if (!apiBase) return `/${path.replace(LEADING_SLASH_RE$1, "")}`;
+	return `${apiBase}/${path.replace(LEADING_SLASH_RE$1, "")}`;
+}
+function mergeHeaders$1(base, extra) {
+	const headers = new Headers(base);
+	if (extra) for (const [key, value] of new Headers(extra).entries()) headers.set(key, value);
+	return headers;
+}
+async function resolveHeaders$1(options) {
+	const resolved = typeof options.headers === "function" ? await options.headers() : options.headers;
+	if (!options.apiKey) return resolved;
+	return mergeHeaders$1(resolved, { "x-api-key": options.apiKey });
+}
+function dataQuery(state, options) {
+	const query = { q: JSON.stringify(state) };
+	if (options?.comparison) query.qc = JSON.stringify(options.comparison);
+	if (options?.filter) query.filter = options.filter;
+	return query;
+}
+function dataDetailQuery(state, options) {
+	const query = { q: JSON.stringify(state) };
+	if (options?.comparison) query.qc = JSON.stringify(options.comparison);
+	return query;
+}
+function assertAnalysisParams(params) {
+	if ((params.preset === "non-brand" || params.preset === "brand-only") && !params.brandTerms?.trim()) throw new Error("brandTerms is required for brand/non-brand presets");
+}
+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;
+	return query;
+}
+function indexingUrlsQuery$1(params = {}) {
+	const query = {};
+	if (params.limit != null) query.limit = params.limit;
+	if (params.offset != null) query.offset = params.offset;
+	if (params.status) query.status = params.status;
+	if (params.issue) query.issue = params.issue;
+	if (params.search) query.search = params.search;
+	return query;
+}
+function tablesQuery$1(tables) {
+	if (!tables) return void 0;
+	return { tables: Array.isArray(tables) ? tables.join(",") : tables };
+}
+function dateRangeQuery(params) {
+	return {
+		startDate: params.startDate,
+		endDate: params.endDate
+	};
+}
+function queryTrendQuery(params) {
+	const query = {
+		startDate: params.startDate,
+		endDate: params.endDate
+	};
+	if (params.prevStartDate) query.prevStartDate = params.prevStartDate;
+	if (params.prevEndDate) query.prevEndDate = params.prevEndDate;
+	return query;
+}
+function shouldValidate$1(options, phase) {
+	return options.validate === true || options.validate === phase;
+}
+function parseWith$1(schema, value) {
+	return schema ? schema.parse(value) : value;
+}
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function createPartnerClient(options = {}) {
+	const fetchImpl = options.fetch ?? ofetch;
+	const apiBase = trimApiBase$1(options.apiBase);
+	async function request(path, init = {}, responseSchema) {
+		const headers = mergeHeaders$1(await resolveHeaders$1(options), init.headers);
+		try {
+			const out = await fetchImpl(buildPath$1(apiBase, path), {
+				...init,
+				headers
+			});
+			return shouldValidate$1(options, "response") ? parseWith$1(responseSchema, out) : out;
+		} catch (error) {
+			throw toPartnerError(error);
+		}
+	}
+	return {
+		registerUser(params) {
+			const body = shouldValidate$1(options, "request") ? partnerEndpointSchemas.registerUser.body.parse(params) : params;
+			return request(partnerRoutes.users.register, {
+				method: "POST",
+				body
+			}, partnerEndpointSchemas.registerUser.response);
+		},
+		updateUserTokens(userId, params) {
+			const body = shouldValidate$1(options, "request") ? partnerEndpointSchemas.updateUserTokens.body.parse(params) : params;
+			return request(partnerRoutes.users.tokens(userId), {
+				method: "PATCH",
+				body
+			}, partnerEndpointSchemas.updateUserTokens.response);
+		},
+		getUserStatus(userId) {
+			return request(partnerRoutes.users.status(userId), {}, partnerEndpointSchemas.getUserStatus.response);
+		},
+		getUserLifecycle(userId) {
+			return request(partnerRoutes.users.lifecycle(userId));
+		},
+		async waitForUserReady(userId, waitOptions = {}) {
+			const attempts = waitOptions.attempts ?? 12;
+			const intervalMs = waitOptions.intervalMs ?? 1e3;
+			let latest = null;
+			for (let attempt = 0; attempt < attempts; attempt++) {
+				latest = await request(partnerRoutes.users.status(userId));
+				if (latest.status === "ready") return latest;
+				if (attempt < attempts - 1) await sleep(intervalMs);
+			}
+			const err = /* @__PURE__ */ new Error("gscdump user database is still provisioning");
+			err.data = latest;
+			throw err;
+		},
+		getUserSites(userId) {
+			return request(partnerRoutes.users.sites(userId), {}, partnerEndpointSchemas.getUserSites.response);
+		},
+		getAvailableSites(userId) {
+			return request(partnerRoutes.users.availableSites(userId), {}, partnerEndpointSchemas.getAvailableSites.response);
+		},
+		registerSite(params) {
+			const body = shouldValidate$1(options, "request") ? partnerEndpointSchemas.registerSite.body.parse(params) : params;
+			return request(partnerRoutes.partner.sites.register, {
+				method: "POST",
+				body
+			}, partnerEndpointSchemas.registerSite.response);
+		},
+		bulkRegisterSites(params) {
+			const body = shouldValidate$1(options, "request") ? partnerEndpointSchemas.bulkRegisterSites.body.parse(params) : params;
+			return request(partnerRoutes.partner.sites.bulkRegister, {
+				method: "POST",
+				body
+			}, partnerEndpointSchemas.bulkRegisterSites.response);
+		},
+		deleteUser(userId) {
+			return request(partnerRoutes.partner.users.byId(userId), { method: "DELETE" }, partnerEndpointSchemas.deleteUser.response);
+		},
+		deleteSite(siteId) {
+			return request(partnerRoutes.sites.byId(siteId), { method: "DELETE" });
+		},
+		getAnalysisSources(siteId, tables) {
+			return request(partnerRoutes.sites.analysisSources(siteId), { query: tablesQuery$1(tables) }, partnerEndpointSchemas.getAnalysisSources.response);
+		},
+		getSiteSyncStatus(siteId) {
+			return request(partnerRoutes.sites.syncStatus(siteId));
+		},
+		getData(siteId, state, queryOptions) {
+			if (shouldValidate$1(options, "request")) {
+				partnerEndpointSchemas.getData.state.parse(state);
+				partnerEndpointSchemas.getData.options.parse(queryOptions);
+			}
+			return request(partnerRoutes.sites.data(siteId), { query: dataQuery(state, queryOptions) }, partnerEndpointSchemas.getData.response);
+		},
+		getDataDetail(siteId, state, queryOptions) {
+			if (shouldValidate$1(options, "request")) {
+				partnerEndpointSchemas.getDataDetail.state.parse(state);
+				partnerEndpointSchemas.getDataDetail.options.parse(queryOptions);
+			}
+			return request(partnerRoutes.sites.dataDetail(siteId), { query: dataDetailQuery(state, queryOptions) }, partnerEndpointSchemas.getDataDetail.response);
+		},
+		getAnalysis(siteId, params) {
+			assertAnalysisParams(params);
+			const query = shouldValidate$1(options, "request") ? partnerEndpointSchemas.getAnalysis.query.parse(params) : params;
+			return request(partnerRoutes.sites.analysis(siteId), { query: analysisQuery(query) }, partnerEndpointSchemas.getAnalysis.response);
+		},
+		getSitemaps(siteId) {
+			return request(partnerRoutes.sites.sitemaps(siteId), {}, partnerEndpointSchemas.getSitemaps.response);
+		},
+		getSitemapChanges(siteId, days = 28) {
+			return request(partnerRoutes.sites.sitemapChanges(siteId), { query: { days } }, partnerEndpointSchemas.getSitemapChanges.response);
+		},
+		submitSitemap(siteId, sitemapUrl, action = "submit") {
+			return request(partnerRoutes.sites.sitemaps(siteId), {
+				method: "POST",
+				body: {
+					sitemapUrl,
+					action
+				}
+			});
+		},
+		refreshSitemaps(siteId) {
+			return request(partnerRoutes.sites.sitemaps(siteId), {
+				method: "POST",
+				body: { action: "refresh" }
+			});
+		},
+		getIndexing(siteId, days = 28) {
+			return request(partnerRoutes.sites.indexing(siteId), { query: { days } }, partnerEndpointSchemas.getIndexing.response);
+		},
+		getIndexingUrls(siteId, params = {}) {
+			const parsed = shouldValidate$1(options, "request") ? partnerEndpointSchemas.getIndexingUrls.query.parse(params) : params;
+			return request(partnerRoutes.sites.indexingUrls(siteId), { query: indexingUrlsQuery$1(parsed) }, partnerEndpointSchemas.getIndexingUrls.response);
+		},
+		getIndexingDiagnostics(siteId) {
+			return request(partnerRoutes.sites.indexingDiagnostics(siteId), {}, partnerEndpointSchemas.getIndexingDiagnostics.response);
+		},
+		getUserSettings() {
+			return request(partnerRoutes.settings.user, {}, partnerEndpointSchemas.getUserSettings.response);
+		},
+		patchUserSettings(body) {
+			const parsed = shouldValidate$1(options, "request") ? partnerEndpointSchemas.patchUserSettings.body.parse(body) : body;
+			return request(partnerRoutes.settings.user, {
+				method: "PATCH",
+				body: parsed
+			}, partnerEndpointSchemas.patchUserSettings.response);
+		},
+		recoverPermission(siteId) {
+			return request(partnerRoutes.sites.recoverPermission(siteId), { method: "POST" }, partnerEndpointSchemas.recoverPermission.response);
+		},
+		getTopAssociation(siteId, params) {
+			const query = shouldValidate$1(options, "request") ? partnerEndpointSchemas.getTopAssociation.query.parse(params) : params;
+			return request(partnerRoutes.sites.topAssociation(siteId), { query }, partnerEndpointSchemas.getTopAssociation.response);
+		},
+		getKeywordSparklines(siteId, params) {
+			const body = shouldValidate$1(options, "request") ? partnerEndpointSchemas.getKeywordSparklines.body.parse(params) : params;
+			return request(partnerRoutes.sites.keywordSparklines(siteId), {
+				method: "POST",
+				body
+			}, partnerEndpointSchemas.getKeywordSparklines.response);
+		},
+		getQueryTrend(siteId, params) {
+			const query = shouldValidate$1(options, "request") ? partnerEndpointSchemas.getQueryTrend.query.parse(params) : params;
+			return request(partnerRoutes.sites.queryTrend(siteId), { query: queryTrendQuery(query) }, partnerEndpointSchemas.getQueryTrend.response);
+		},
+		getCanonicalMismatches(siteId) {
+			return request(partnerRoutes.sites.canonicalMismatches(siteId), {}, partnerEndpointSchemas.getCanonicalMismatches.response);
+		},
+		getContentVelocity(siteId, days) {
+			return request(partnerRoutes.sites.contentVelocity(siteId), { query: days == null ? void 0 : { days } });
+		},
+		getCtrCurve(siteId, params) {
+			const query = shouldValidate$1(options, "request") ? partnerEndpointSchemas.getDateRangeInsight.query.parse(params) : params;
+			return request(partnerRoutes.sites.ctrCurve(siteId), { query: dateRangeQuery(query) });
+		},
+		getDarkTraffic(siteId, params) {
+			const query = shouldValidate$1(options, "request") ? partnerEndpointSchemas.getDateRangeInsight.query.parse(params) : params;
+			return request(partnerRoutes.sites.darkTraffic(siteId), { query: dateRangeQuery(query) });
+		},
+		getDeviceGap(siteId, params) {
+			const query = shouldValidate$1(options, "request") ? partnerEndpointSchemas.getDateRangeInsight.query.parse(params) : params;
+			return request(partnerRoutes.sites.deviceGap(siteId), { query: dateRangeQuery(query) });
+		},
+		getIndexPercent(siteId, params = {}) {
+			const query = shouldValidate$1(options, "request") ? partnerEndpointSchemas.getIndexPercent.query.parse(params) : params;
+			return request(partnerRoutes.sites.indexPercent(siteId), { query }, partnerEndpointSchemas.getIndexPercent.response);
+		},
+		getKeywordBreadth(siteId, params) {
+			const query = shouldValidate$1(options, "request") ? partnerEndpointSchemas.getDateRangeInsight.query.parse(params) : params;
+			return request(partnerRoutes.sites.keywordBreadth(siteId), { query: dateRangeQuery(query) });
+		},
+		getPositionDistribution(siteId, params) {
+			const query = shouldValidate$1(options, "request") ? partnerEndpointSchemas.getDateRangeInsight.query.parse(params) : params;
+			return request(partnerRoutes.sites.positionDistribution(siteId), { query: dateRangeQuery(query) });
+		},
+		createTeam(params) {
+			const body = shouldValidate$1(options, "request") ? partnerEndpointSchemas.createTeam.body.parse(params) : params;
+			return request(partnerRoutes.teams.create, {
+				method: "POST",
+				body
+			}, partnerEndpointSchemas.createTeam.response);
+		},
+		renameTeam(teamId, params) {
+			return request(partnerRoutes.teams.byId(teamId), {
+				method: "PATCH",
+				body: params
+			});
+		},
+		deleteTeam(teamId) {
+			return request(partnerRoutes.teams.byId(teamId), { method: "DELETE" });
+		},
+		listTeamMembers(teamId) {
+			return request(partnerRoutes.teams.members(teamId), {}, partnerEndpointSchemas.listTeamMembers.response);
+		},
+		addTeamMember(teamId, params) {
+			const body = shouldValidate$1(options, "request") ? partnerEndpointSchemas.addTeamMember.body.parse(params) : params;
+			return request(partnerRoutes.teams.members(teamId), {
+				method: "POST",
+				body
+			}, partnerEndpointSchemas.addTeamMember.response);
+		},
+		updateTeamMemberRole(teamId, userId, params) {
+			return request(partnerRoutes.teams.member(teamId, userId), {
+				method: "PATCH",
+				body: params
+			});
+		},
+		removeTeamMember(teamId, userId) {
+			return request(partnerRoutes.teams.member(teamId, userId), { method: "DELETE" });
+		},
+		bindSiteToTeam(userId, siteId, params) {
+			const body = shouldValidate$1(options, "request") ? partnerEndpointSchemas.bindSiteToTeam.body.parse(params) : params;
+			return request(partnerRoutes.partner.users.siteTeam(userId, siteId), {
+				method: "PATCH",
+				body
+			}, partnerEndpointSchemas.bindSiteToTeam.response);
+		}
+	};
+}
+const createGscdumpClient = createPartnerClient;
+const TRAILING_SLASH_RE$1 = /\/+$/;
+const LEADING_SLASH_RE = /^\/+/;
+function trimApiBase(apiBase) {
+	return (apiBase ?? "").replace(TRAILING_SLASH_RE$1, "");
+}
+function buildPath(apiBase, path) {
+	if (!apiBase) return path.startsWith("/") ? path : `/${path}`;
+	return `${apiBase}/${path.replace(LEADING_SLASH_RE, "")}`;
+}
+function mergeHeaders(base, extra) {
+	const headers = new Headers(base);
+	if (extra) for (const [key, value] of new Headers(extra).entries()) headers.set(key, value);
+	return headers;
+}
+async function resolveHeaders(options) {
+	return typeof options.headers === "function" ? await options.headers() : options.headers;
+}
+function shouldValidate(options, phase) {
+	return options.validate === true || options.validate === phase;
+}
+function parseWith(schema, value) {
+	return schema ? schema.parse(value) : value;
+}
+function tablesQuery(tables) {
+	if (!tables) return void 0;
+	return { tables: Array.isArray(tables) ? tables.join(",") : tables };
+}
+function indexingUrlsQuery(params = {}) {
+	const query = {};
+	if (params.limit != null) query.limit = params.limit;
+	if (params.offset != null) query.offset = params.offset;
+	if (params.status) query.status = params.status;
+	if (params.issue) query.issue = params.issue;
+	if (params.search) query.search = params.search;
+	return query;
+}
+function createAnalyticsClient(options = {}) {
+	const fetchImpl = options.fetch ?? ofetch;
+	const apiBase = trimApiBase(options.apiBase);
+	async function request(path, init = {}, responseSchema) {
+		const headers = mergeHeaders(await resolveHeaders(options), init.headers);
+		try {
+			const out = await fetchImpl(buildPath(apiBase, path), {
+				...init,
+				headers
+			});
+			return shouldValidate(options, "response") ? parseWith(responseSchema, out) : out;
+		} catch (error) {
+			throw toPartnerError(error);
+		}
+	}
+	return {
+		whoami() {
+			return request(analyticsRoutes.whoami, {}, partnerEndpointSchemas.analyticsWhoami.response);
+		},
+		listSites() {
+			return request(analyticsRoutes.sites, {}, partnerEndpointSchemas.analyticsSites.response);
+		},
+		getSourceInfo(siteId) {
+			return request(analyticsRoutes.site.sourceInfo(siteId), {}, partnerEndpointSchemas.analyticsSourceInfo.response);
+		},
+		getAnalysisSources(siteId, tables) {
+			return request(analyticsRoutes.site.analysisSources(siteId), { query: tablesQuery(tables) }, partnerEndpointSchemas.analyticsAnalysisSources.response);
+		},
+		analyze(siteId, params) {
+			return request(analyticsRoutes.site.analyze(siteId), {
+				method: "POST",
+				body: params
+			});
+		},
+		queryRows(siteId, state) {
+			return request(analyticsRoutes.site.rows(siteId), {
+				method: "POST",
+				body: state
+			}, partnerEndpointSchemas.analyticsRows.response);
+		},
+		getRollup(siteId, rollupId, params) {
+			return request(analyticsRoutes.site.rollup(siteId, rollupId), { query: params }, partnerEndpointSchemas.analyticsRollup.response);
+		},
+		requestBackfill(siteId, range) {
+			const body = shouldValidate(options, "request") ? partnerEndpointSchemas.analyticsBackfill.body.parse(range) : range;
+			return request(analyticsRoutes.site.backfill(siteId), {
+				method: "POST",
+				body
+			}, partnerEndpointSchemas.analyticsBackfill.response);
+		},
+		getSitemaps(siteId) {
+			return request(analyticsRoutes.site.sitemaps(siteId), {}, partnerEndpointSchemas.analyticsSitemaps.response);
+		},
+		getSitemapHistory(siteId, hash) {
+			return request(analyticsRoutes.site.sitemapHistory(siteId, hash), {}, partnerEndpointSchemas.analyticsSitemapHistory.response);
+		},
+		getSitemapChanges(siteId, params = {}) {
+			return request(analyticsRoutes.site.sitemapChanges(siteId), { query: params }, partnerEndpointSchemas.analyticsSitemapChanges.response);
+		},
+		getInspections(siteId) {
+			return request(analyticsRoutes.site.inspections(siteId), {}, partnerEndpointSchemas.analyticsInspections.response);
+		},
+		getInspectionHistory(siteId, hash) {
+			return request(analyticsRoutes.site.inspectionHistory(siteId, hash), {}, partnerEndpointSchemas.analyticsInspectionHistory.response);
+		},
+		getIndexingUrls(siteId, params = {}) {
+			return request(analyticsRoutes.site.indexingUrls(siteId), { query: indexingUrlsQuery(params) }, partnerEndpointSchemas.analyticsIndexingUrls.response);
+		},
+		getIndexingDiagnostics(siteId) {
+			return request(analyticsRoutes.site.indexingDiagnostics(siteId), {}, partnerEndpointSchemas.analyticsIndexingDiagnostics.response);
+		}
+	};
+}
+const encoder = new TextEncoder();
+function toPayloadString(payload) {
+	return typeof payload === "string" ? payload : JSON.stringify(payload);
+}
+function hexToBytes(hex) {
+	if (!/^[\da-f]+$/i.test(hex) || hex.length % 2 !== 0) return null;
+	const bytes = new Uint8Array(hex.length / 2);
+	for (let i = 0; i < bytes.length; i++) bytes[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+	return bytes;
+}
+function constantTimeEqual(a, b) {
+	if (a.length !== b.length) return false;
+	let diff = 0;
+	for (let i = 0; i < a.length; i++) diff |= a[i] ^ b[i];
+	return diff === 0;
+}
+function signatureHex(signature) {
+	const trimmed = signature.trim();
+	return trimmed.startsWith("sha256=") ? trimmed.slice(7) : null;
+}
+async function hmacSha256(payload, secret) {
+	const key = await crypto.subtle.importKey("raw", encoder.encode(secret), {
+		name: "HMAC",
+		hash: "SHA-256"
+	}, false, ["sign"]);
+	return crypto.subtle.sign("HMAC", key, encoder.encode(payload));
+}
+function toCanonicalWebhookEvent(event) {
+	return WEBHOOK_EVENT_ALIASES$1[event] ?? event;
+}
+function serializeWebhookPayload(payload) {
+	return toPayloadString(payload);
+}
+async function verifyWebhookSignature(payload, signature, secret) {
+	if (!signature) return false;
+	const hex = signatureHex(signature);
+	if (!hex) return false;
+	const received = hexToBytes(hex);
+	if (!received) return false;
+	return constantTimeEqual(new Uint8Array(await hmacSha256(toPayloadString(payload), secret)), received);
+}
+async function parseWebhookPayload(payload, options = {}) {
+	const payloadString = toPayloadString(payload);
+	const signature = options.signature ?? readWebhookHeaders(options.headers).signature;
+	if (options.secret && (options.validateSignature ?? true)) {
+		if (!await verifyWebhookSignature(payloadString, signature, options.secret)) throw new PartnerApiError({
+			kind: "auth",
+			statusCode: 401,
+			message: "Invalid webhook signature"
+		});
+	}
+	const parsed = typeof payload === "string" ? JSON.parse(payload) : payload;
+	return partnerWebhookEnvelopeSchema.parse(parsed);
+}
+function readWebhookHeaders(headers) {
+	if (!headers) return {
+		event: null,
+		delivery: null,
+		contractVersion: null,
+		timestamp: null,
+		signature: null
+	};
+	if (headers instanceof Headers) return {
+		event: headers.get(WEBHOOK_EVENT_HEADER$1),
+		delivery: headers.get(WEBHOOK_DELIVERY_HEADER$1),
+		contractVersion: headers.get(WEBHOOK_CONTRACT_VERSION_HEADER$1),
+		timestamp: headers.get(WEBHOOK_TIMESTAMP_HEADER$1),
+		signature: headers.get(WEBHOOK_SIGNATURE_HEADER$1)
+	};
+	return {
+		event: headers.event ?? null,
+		delivery: headers.delivery ?? null,
+		contractVersion: headers.contractVersion ?? null,
+		timestamp: headers.timestamp ?? null,
+		signature: headers.signature ?? null
+	};
+}
+const HTTP_PROTOCOL_RE = /^http/i;
+const API_SUFFIX_RE = /\/api\/?$/;
+const TRAILING_SLASH_RE = /\/+$/;
+function inferWsBase(options) {
+	if (options.wsBase) return options.wsBase.replace(TRAILING_SLASH_RE, "");
+	if (!options.apiBase) return "";
+	return options.apiBase.replace(API_SUFFIX_RE, "").replace(TRAILING_SLASH_RE, "").replace(HTTP_PROTOCOL_RE, (m) => m.toLowerCase() === "https" ? "wss" : "ws");
+}
+function wsPath(scope) {
+	return scope === "partner" ? partnerRoutes.realtime.partner : partnerRoutes.realtime.user;
+}
+function buildWsUrl(options) {
+	const scope = options.scope ?? "partner";
+	const base = inferWsBase(options);
+	if (!base) return wsPath(scope);
+	return `${base}${wsPath(scope)}`;
+}
+function parseMessage(raw) {
+	if (typeof raw !== "string") return null;
+	try {
+		return JSON.parse(raw);
+	} catch {
+		return null;
+	}
+}
+function isRealtimeEvent(message) {
+	return "event" in message && message.event !== "auth.required" && message.event !== "connected";
+}
+function getWebSocketCtor(options) {
+	const ctor = options.WebSocket ?? globalThis.WebSocket;
+	if (!ctor) throw new Error("WebSocket is not available; pass options.WebSocket");
+	return ctor;
+}
+function createPartnerRealtimeClient(options) {
+	let socket = null;
+	let status = "idle";
+	const statusHandlers = /* @__PURE__ */ new Set();
+	const messageHandlers = /* @__PURE__ */ new Set();
+	const eventHandlers = /* @__PURE__ */ new Set();
+	const errorHandlers = /* @__PURE__ */ new Set();
+	function setStatus(next) {
+		status = next;
+		for (const handler of statusHandlers) handler(next);
+	}
+	function sendJson(payload) {
+		if (!socket) throw new Error("Partner realtime client is not connected");
+		socket.send(JSON.stringify(payload));
+	}
+	function authPayload() {
+		const payload = {
+			type: "auth",
+			apiKey: options.apiKey
+		};
+		if (options.userId != null) payload.userId = options.userId;
+		return payload;
+	}
+	function subscribe(siteIds) {
+		sendJson({
+			type: "subscribe",
+			siteIds
+		});
+	}
+	return {
+		get status() {
+			return status;
+		},
+		get socket() {
+			return socket;
+		},
+		connect() {
+			if (socket) return socket;
+			socket = new (getWebSocketCtor(options))(buildWsUrl(options), options.protocols);
+			setStatus("connecting");
+			socket.onopen = () => {
+				setStatus("open");
+				sendJson(authPayload());
+			};
+			socket.onmessage = (event) => {
+				const message = parseMessage(event.data);
+				if (!message) return;
+				if ("event" in message && message.event === "connected") {
+					setStatus("authenticated");
+					if (options.siteIds?.length) subscribe(options.siteIds);
+				}
+				for (const handler of messageHandlers) handler(message);
+				if (isRealtimeEvent(message)) for (const handler of eventHandlers) handler(message);
+			};
+			socket.onerror = (event) => {
+				setStatus("error");
+				for (const handler of errorHandlers) handler(event);
+			};
+			socket.onclose = (event) => {
+				socket = null;
+				setStatus("closed");
+				for (const handler of messageHandlers) handler({
+					type: "error",
+					message: `WebSocket closed: ${JSON.stringify(event)}`
+				});
+			};
+			return socket;
+		},
+		close(code, reason) {
+			socket?.close(code, reason);
+			socket = null;
+			setStatus("closed");
+		},
+		ping() {
+			sendJson({ type: "ping" });
+		},
+		subscribe,
+		onStatus(handler) {
+			statusHandlers.add(handler);
+			return () => statusHandlers.delete(handler);
+		},
+		onMessage(handler) {
+			messageHandlers.add(handler);
+			return () => messageHandlers.delete(handler);
+		},
+		onEvent(handler) {
+			eventHandlers.add(handler);
+			return () => eventHandlers.delete(handler);
+		},
+		onError(handler) {
+			errorHandlers.add(handler);
+			return () => errorHandlers.delete(handler);
+		}
+	};
+}
+const createGscdumpRealtimeClient = createPartnerRealtimeClient;
+export { CANONICAL_WEBHOOK_EVENTS, LEGACY_WEBHOOK_EVENTS, PartnerApiError, VALID_WEBHOOK_EVENTS, WEBHOOK_CONTRACT_VERSION, WEBHOOK_CONTRACT_VERSION_HEADER, WEBHOOK_DELIVERY_HEADER, WEBHOOK_EVENT_ALIASES, WEBHOOK_EVENT_HEADER, WEBHOOK_SIGNATURE_HEADER, WEBHOOK_TIMESTAMP_HEADER, createAnalyticsClient, createGscdumpClient, createGscdumpRealtimeClient, createPartnerClient, createPartnerRealtimeClient, parseWebhookPayload, readWebhookHeaders, serializeWebhookPayload, toCanonicalWebhookEvent, toPartnerError, verifyWebhookSignature };

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@gscdump/sdk",
+  "type": "module",
+  "version": "0.11.4",
+  "description": "Consumer SDK for hosted gscdump.com integrations.",
+  "author": {
+    "name": "Harlan Wilton",
+    "email": "harlan@harlanzw.com",
+    "url": "https://harlanzw.com/"
+  },
+  "license": "MIT",
+  "funding": "https://github.com/sponsors/harlan-zw",
+  "homepage": "https://github.com/harlan-zw/gscdump/tree/main/packages/sdk#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/harlan-zw/gscdump.git",
+    "directory": "packages/sdk"
+  },
+  "bugs": {
+    "url": "https://github.com/harlan-zw/gscdump/issues"
+  },
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "ofetch": "^1.5.1",
+    "zod": "^4.4.3",
+    "@gscdump/contracts": "0.11.4"
+  },
+  "devDependencies": {
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.5"
+  },
+  "scripts": {
+    "build": "obuild",
+    "dev": "obuild --stub",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest"
+  }
+}