@gscdump/contracts 1.1.0 → 1.3.0

package/dist/v1/index.mjs

@@ -1,4 +1,4 @@
-import { accountNextActions, accountStatuses, analyticsNextActions, analyticsStatuses, builderStateSchema, gscComparisonFilterSchema, gscdumpAnalysisBundleResponseSchema, gscdumpAnalysisPresetSchema, gscdumpAnalysisResponseSchema, gscdumpAvailableSiteSchema, gscdumpCanonicalMismatchesResponseSchema, gscdumpDataDetailResponseSchema, gscdumpDataResponseSchema, gscdumpIndexingDiagnosticsResponseSchema, gscdumpIndexingResponseSchema, gscdumpKeywordSparklinesResponseSchema, gscdumpPageTrendResponseSchema, gscdumpQueryTrendResponseSchema, gscdumpSiteRegistrationSchema, gscdumpSitemapChangesResponseSchema, gscdumpSitemapsResponseSchema, gscdumpUserRegistrationSchema, indexingNextActions, indexingStatuses, indexingUrlsResponseSchema, lifecycleErrorCodes, propertyNextActions, propertyStatuses, querySourceModes, registerPartnerSiteSchema, registerPartnerUserSchema, searchTypeSchema, sitemapNextActions, sitemapStatuses, updatePartnerUserTokensSchema } from "../_chunks/schemas.mjs";
+import { accountNextActions, accountStatuses, addPartnerTeamMemberSchema, analyticsNextActions, analyticsStatuses, bindPartnerSiteTeamSchema, bindPartnerTeamCatalogResponseSchema, bindPartnerTeamCatalogSchema, builderStateSchema, createPartnerTeamSchema, gscComparisonFilterSchema, gscdumpAnalysisBundleResponseSchema, gscdumpAnalysisPresetSchema, gscdumpAnalysisResponseSchema, gscdumpAvailableSiteSchema, gscdumpCanonicalMismatchesResponseSchema, gscdumpDataDetailResponseSchema, gscdumpDataResponseSchema, gscdumpDeletePartnerUserResponseSchema, gscdumpIndexPercentResponseSchema, gscdumpIndexingDiagnosticsResponseSchema, gscdumpIndexingResponseSchema, gscdumpKeywordSparklinesResponseSchema, gscdumpPageTrendResponseSchema, gscdumpQueryTrendResponseSchema, gscdumpSiteRegistrationSchema, gscdumpSitemapChangesResponseSchema, gscdumpSitemapMembershipParamsSchema, gscdumpSitemapMembershipResponseSchema, gscdumpSitemapsResponseSchema, gscdumpTeamRoleSchema, gscdumpTopAssociationResponseSchema, gscdumpUserRegistrationSchema, indexingNextActions, indexingStatuses, indexingUrlsResponseSchema, lifecycleErrorCodes, partnerSiteTeamBindingResponseSchema, partnerSitemapActionResponseSchema, partnerSitemapActionSchema, partnerTeamCreatedResponseSchema, partnerTeamDeletedResponseSchema, partnerTeamMemberAddedResponseSchema, partnerTeamMemberRemovedResponseSchema, partnerTeamMemberRoleResponseSchema, partnerTeamMembersResponseSchema, partnerTeamRenamedResponseSchema, propertyNextActions, propertyStatuses, querySourceModes, registerPartnerSiteSchema, registerPartnerUserSchema, renamePartnerTeamSchema, searchTypeSchema, siteIntIdCrosswalkResponseSchema, sitemapNextActions, sitemapStatuses, teamCatalogRefSchema, updatePartnerUserTokensSchema } from "../_chunks/schemas.mjs";
 import { z } from "zod";
 const HTTP_V1_SURFACES = [
 	"partner",
@@ -1050,6 +1050,232 @@ function createGscdumpV1Protocol() {
 			reason: z.enum(["domain_mismatch", "rate_limited"])
 		}))
 	}), partnerResponseMeta);
+	const dateRangeQuery = z.strictObject({
+		startDate: calendarDate,
+		endDate: calendarDate
+	});
+	const siteDataMeta = z.object({
+		siteUrl: z.string().nullable(),
+		syncStatus: z.string().nullable()
+	});
+	const contentVelocityResponse = defineSuccessResponse(defineResponseObject({
+		weekly: z.array(z.strictObject({
+			week: z.string(),
+			newKeywords: z.number().int().nonnegative(),
+			totalKeywords: z.number().int().nonnegative()
+		})),
+		summary: z.strictObject({
+			totalNewKeywords: z.number().int().nonnegative(),
+			avgPerWeek: z.number().nonnegative(),
+			trend: z.enum([
+				"stable",
+				"accelerating",
+				"decelerating"
+			])
+		}),
+		meta: siteDataMeta
+	}), partnerResponseMeta);
+	const ctrOutlier = z.strictObject({
+		query: z.string(),
+		clicks: z.number(),
+		impressions: z.number(),
+		ctr: z.number(),
+		position: z.number(),
+		expectedCtr: z.number(),
+		ctrDiff: z.number()
+	});
+	const ctrCurveResponse = defineSuccessResponse(defineResponseObject({
+		curve: z.array(z.strictObject({
+			bucket: z.string(),
+			avgCtr: z.number(),
+			medianPosition: z.number(),
+			keywordCount: z.number(),
+			totalClicks: z.number(),
+			totalImpressions: z.number()
+		})),
+		overperforming: z.array(ctrOutlier),
+		underperforming: z.array(ctrOutlier),
+		meta: siteDataMeta
+	}), partnerResponseMeta);
+	const darkTrafficResponse = defineSuccessResponse(defineResponseObject({
+		summary: z.strictObject({
+			totalClicks: z.number(),
+			attributedClicks: z.number(),
+			darkClicks: z.number(),
+			darkPercent: z.number(),
+			totalImpressions: z.number(),
+			attributedImpressions: z.number()
+		}),
+		pages: z.array(z.strictObject({
+			url: z.string(),
+			totalClicks: z.number(),
+			attributedClicks: z.number(),
+			darkClicks: z.number(),
+			darkPercent: z.number(),
+			keywordCount: z.number()
+		})),
+		meta: siteDataMeta
+	}), partnerResponseMeta);
+	const deviceGapMetrics = z.strictObject({
+		clicks: z.number(),
+		impressions: z.number(),
+		ctr: z.number(),
+		position: z.number()
+	});
+	const deviceGapResponse = defineSuccessResponse(defineResponseObject({
+		daily: z.array(z.strictObject({
+			date: z.string(),
+			desktop: deviceGapMetrics,
+			mobile: deviceGapMetrics,
+			gaps: z.strictObject({
+				ctrGap: z.number(),
+				positionGap: z.number()
+			})
+		})),
+		summary: z.strictObject({
+			avgCtrGap: z.number(),
+			avgPositionGap: z.number(),
+			ctrGapTrend: z.enum([
+				"stable",
+				"improving",
+				"worsening"
+			]),
+			positionGapTrend: z.enum([
+				"stable",
+				"improving",
+				"worsening"
+			])
+		}).nullable(),
+		meta: siteDataMeta
+	}), partnerResponseMeta);
+	const keywordBreadthPage = z.strictObject({
+		url: z.string(),
+		keywordCount: z.number(),
+		clicks: z.number(),
+		impressions: z.number()
+	});
+	const keywordBreadthResponse = defineSuccessResponse(defineResponseObject({
+		distribution: z.array(z.strictObject({
+			bucket: z.string(),
+			pageCount: z.number()
+		})),
+		fragilePages: z.array(keywordBreadthPage),
+		authorityPages: z.array(keywordBreadthPage),
+		summary: z.strictObject({
+			totalPages: z.number(),
+			avgKeywordsPerPage: z.number(),
+			fragileCount: z.number(),
+			authorityCount: z.number()
+		}),
+		meta: siteDataMeta
+	}), partnerResponseMeta);
+	const positionDistributionResponse = defineSuccessResponse(defineResponseObject({
+		distribution: z.array(z.strictObject({
+			date: z.string(),
+			pos_1_3: z.number(),
+			pos_4_10: z.number(),
+			pos_11_20: z.number(),
+			pos_20_plus: z.number(),
+			total: z.number()
+		})),
+		meta: siteDataMeta
+	}), partnerResponseMeta);
+	const topAssociationQuery = z.strictObject({
+		type: z.enum(["topPage", "topKeyword"]),
+		identifier: z.string().min(1),
+		startDate: calendarDate,
+		endDate: calendarDate
+	});
+	const topAssociationResponse = defineSuccessResponse(defineResponseObject(gscdumpTopAssociationResponseSchema.shape), partnerResponseMeta);
+	const indexPercentQuery = z.strictObject({
+		invisibleLimit: z.coerce.number().int().min(1).max(500).optional(),
+		invisibleOffset: z.coerce.number().int().min(0).max(1e6).optional(),
+		orphanLimit: z.coerce.number().int().min(1).max(500).optional()
+	});
+	const indexPercentResponse = defineSuccessResponse(defineResponseObject(gscdumpIndexPercentResponseSchema.shape), partnerResponseMeta);
+	const contentVelocityQuery = z.strictObject({ days: z.coerce.number().int().min(1).max(365).optional() });
+	const sitemapActionRequest = partnerSitemapActionSchema;
+	const sitemapActionResponse = defineSuccessResponse({
+		producer: partnerSitemapActionResponseSchema,
+		client: partnerSitemapActionResponseSchema
+	}, partnerResponseMeta);
+	const sitemapMembershipRequest = gscdumpSitemapMembershipParamsSchema.strict();
+	const sitemapMembershipResponse = defineSuccessResponse(defineResponseObject(gscdumpSitemapMembershipResponseSchema.shape), partnerResponseMeta);
+	const createTeamRequest = createPartnerTeamSchema.strict();
+	const teamCreatedResponse = defineSuccessResponse(defineResponseObject(partnerTeamCreatedResponseSchema.shape), partnerResponseMeta);
+	const renameTeamRequest = renamePartnerTeamSchema.strict();
+	const teamRenamedResponse = defineSuccessResponse(defineResponseObject(partnerTeamRenamedResponseSchema.shape), partnerResponseMeta);
+	const teamDeletedResponse = defineSuccessResponse(defineResponseObject(partnerTeamDeletedResponseSchema.shape), partnerResponseMeta);
+	const teamMembersResponse = defineSuccessResponse(defineResponseObject(partnerTeamMembersResponseSchema.shape), partnerResponseMeta);
+	const addTeamMemberRequest = addPartnerTeamMemberSchema.strict();
+	const teamMemberAddedResponse = defineSuccessResponse(defineResponseObject(partnerTeamMemberAddedResponseSchema.shape), partnerResponseMeta);
+	const updateTeamMemberRoleRequest = z.strictObject({ role: gscdumpTeamRoleSchema });
+	const teamMemberRoleResponse = defineSuccessResponse(defineResponseObject(partnerTeamMemberRoleResponseSchema.shape), partnerResponseMeta);
+	const teamMemberRemovedResponse = defineSuccessResponse(defineResponseObject(partnerTeamMemberRemovedResponseSchema.shape), partnerResponseMeta);
+	const bindSiteTeamRequest = bindPartnerSiteTeamSchema.strict();
+	const siteTeamBindingResponse = defineSuccessResponse(defineResponseObject(partnerSiteTeamBindingResponseSchema.shape), partnerResponseMeta);
+	const teamCatalogResponse = defineSuccessResponse(defineResponseObject(teamCatalogRefSchema.shape), partnerResponseMeta);
+	const bindTeamCatalogRequest = bindPartnerTeamCatalogSchema.strict();
+	const teamCatalogBindResponse = defineSuccessResponse(defineResponseObject(bindPartnerTeamCatalogResponseSchema.shape), partnerResponseMeta);
+	const siteIntIdCrosswalkResponse = defineSuccessResponse(defineResponseObject(siteIntIdCrosswalkResponseSchema.shape), partnerResponseMeta);
+	const deletePartnerUserResponse = defineSuccessResponse(defineResponseObject(gscdumpDeletePartnerUserResponseSchema.shape), partnerResponseMeta);
+	const verificationMethodSchema = z.enum([
+		"META",
+		"FILE",
+		"DNS_TXT",
+		"DNS_CNAME",
+		"ANALYTICS",
+		"TAG_MANAGER"
+	]);
+	const verificationTokenRequest = z.strictObject({
+		siteUrl: z.string().min(1),
+		method: verificationMethodSchema.optional()
+	});
+	const verificationSiteShape = z.object({
+		type: z.string(),
+		identifier: z.string()
+	}).loose();
+	const verificationTokenResponse = defineSuccessResponse(defineResponseObject({
+		siteUrl: z.string(),
+		site: verificationSiteShape,
+		method: z.string(),
+		token: z.string(),
+		metaContent: z.string().nullable(),
+		dnsRecord: z.object({
+			type: z.enum(["TXT", "CNAME"]),
+			host: z.string(),
+			value: z.string()
+		}).nullable()
+	}), partnerResponseMeta);
+	const addAndVerifySiteRequest = verificationTokenRequest;
+	const addAndVerifySiteResponse = defineSuccessResponse(defineResponseObject({
+		siteUrl: z.string(),
+		site: verificationSiteShape,
+		method: z.string(),
+		verified: z.literal(true),
+		owners: z.array(z.string()).optional()
+	}), partnerResponseMeta);
+	const crossSourceRequest = z.strictObject({
+		queryKey: z.enum([
+			"crawl-error-losing-impressions",
+			"declining-clicks-poor-lcp",
+			"striking-distance-slow-pages",
+			"top-impressions-low-performance"
+		]),
+		rangeDays: z.number().int().positive().max(180).optional(),
+		limit: z.number().int().positive().max(500).optional()
+	});
+	const crossSourceResponse = defineSuccessResponse(defineResponseObject({
+		reason: z.string().optional(),
+		sources: z.array(z.string()),
+		rows: z.array(z.record(z.string(), z.json()))
+	}), partnerResponseMeta);
+	const enrichKeywordsRequest = z.strictObject({ keywords: z.array(z.string().min(1)).min(1).max(500) });
+	const enrichKeywordsResponse = defineSuccessResponse(defineResponseObject({ metrics: z.record(z.string(), z.object({
+		difficulty: z.number().nullable(),
+		searchVolume: z.number().nullable(),
+		cpc: z.number().nullable()
+	}).loose()) }), partnerResponseMeta);
 	const responseStreamHead = defineResponseObject({
 		streamId: realtimeSchemas.streamId,
 		sequence: realtimeSchemas.sequence
@@ -2447,6 +2673,1782 @@ function createGscdumpV1Protocol() {
 						}
 					}
 				}
+			}),
+			getContentVelocity: defineHttpOperation({
+				id: "partner.sites.content.velocity.get",
+				method: "GET",
+				path: "/sites/{siteId}/content-velocity",
+				visibility: "public",
+				semantics: {
+					kind: "query",
+					sideEffects: "none",
+					idempotent: true,
+					retry: "idempotent",
+					readConsistency: "primary"
+				},
+				auth: {
+					credentials: ["user_key", "partner_key"],
+					scopes: ["analytics:read"],
+					ownership: [{
+						credential: "user_key",
+						rule: "authorized_site"
+					}, {
+						credential: "partner_key",
+						rule: "authorized_site"
+					}]
+				},
+				request: {
+					params: z.strictObject({ siteId: realtimeSchemas.publicSiteId }),
+					query: contentVelocityQuery,
+					headers: requestHeaders,
+					body: null
+				},
+				responses: { 200: contentVelocityResponse },
+				errors: partnerSiteErrors,
+				errorResponse: errorEnvelopeSchemas(partnerSiteErrors, realtimeSchemas.publicRequestId),
+				resources: {
+					reads: [{
+						type: "site.analytics",
+						idFrom: "params.siteId"
+					}],
+					changes: []
+				},
+				lifecycle: { introduced: "1.2.0" },
+				docs: {
+					summary: "Get content velocity",
+					description: "Returns the weekly new-keyword series over the requested window with a summary trend.",
+					tags: ["Analytics"],
+					examples: {
+						request: {
+							params: { siteId: "s_01" },
+							query: { days: 90 }
+						},
+						response: {
+							data: {
+								weekly: [],
+								summary: {
+									totalNewKeywords: 0,
+									avgPerWeek: 0,
+									trend: "stable"
+								},
+								meta: {
+									siteUrl: "sc-domain:example.com",
+									syncStatus: "synced"
+								}
+							},
+							meta: {
+								requestId: "req_01",
+								surface: "partner",
+								version: "1.0"
+							}
+						}
+					}
+				}
+			}),
+			getCtrCurve: defineHttpOperation({
+				id: "partner.sites.ctr.curve.get",
+				method: "GET",
+				path: "/sites/{siteId}/ctr-curve",
+				visibility: "public",
+				semantics: {
+					kind: "query",
+					sideEffects: "none",
+					idempotent: true,
+					retry: "idempotent",
+					readConsistency: "primary"
+				},
+				auth: {
+					credentials: ["user_key", "partner_key"],
+					scopes: ["analytics:read"],
+					ownership: [{
+						credential: "user_key",
+						rule: "authorized_site"
+					}, {
+						credential: "partner_key",
+						rule: "authorized_site"
+					}]
+				},
+				request: {
+					params: z.strictObject({ siteId: realtimeSchemas.publicSiteId }),
+					query: dateRangeQuery,
+					headers: requestHeaders,
+					body: null
+				},
+				responses: { 200: ctrCurveResponse },
+				errors: partnerSiteErrors,
+				errorResponse: errorEnvelopeSchemas(partnerSiteErrors, realtimeSchemas.publicRequestId),
+				resources: {
+					reads: [{
+						type: "site.analytics",
+						idFrom: "params.siteId"
+					}],
+					changes: []
+				},
+				lifecycle: { introduced: "1.2.0" },
+				docs: {
+					summary: "Get CTR curve and outliers",
+					description: "Returns the position-bucketed CTR curve plus over/under-performing query outliers for the window.",
+					tags: ["Analytics"],
+					examples: {
+						request: {
+							params: { siteId: "s_01" },
+							query: {
+								startDate: "2026-06-01",
+								endDate: "2026-06-28"
+							}
+						},
+						response: {
+							data: {
+								curve: [],
+								overperforming: [],
+								underperforming: [],
+								meta: {
+									siteUrl: "sc-domain:example.com",
+									syncStatus: "synced"
+								}
+							},
+							meta: {
+								requestId: "req_01",
+								surface: "partner",
+								version: "1.0"
+							}
+						}
+					}
+				}
+			}),
+			getDarkTraffic: defineHttpOperation({
+				id: "partner.sites.dark.traffic.get",
+				method: "GET",
+				path: "/sites/{siteId}/dark-traffic",
+				visibility: "public",
+				semantics: {
+					kind: "query",
+					sideEffects: "none",
+					idempotent: true,
+					retry: "idempotent",
+					readConsistency: "primary"
+				},
+				auth: {
+					credentials: ["user_key", "partner_key"],
+					scopes: ["analytics:read"],
+					ownership: [{
+						credential: "user_key",
+						rule: "authorized_site"
+					}, {
+						credential: "partner_key",
+						rule: "authorized_site"
+					}]
+				},
+				request: {
+					params: z.strictObject({ siteId: realtimeSchemas.publicSiteId }),
+					query: dateRangeQuery,
+					headers: requestHeaders,
+					body: null
+				},
+				responses: { 200: darkTrafficResponse },
+				errors: partnerSiteErrors,
+				errorResponse: errorEnvelopeSchemas(partnerSiteErrors, realtimeSchemas.publicRequestId),
+				resources: {
+					reads: [{
+						type: "site.analytics",
+						idFrom: "params.siteId"
+					}],
+					changes: []
+				},
+				lifecycle: { introduced: "1.2.0" },
+				docs: {
+					summary: "Get dark traffic breakdown",
+					description: "Returns clicks not attributable to any tracked keyword, in total and per page, for the window.",
+					tags: ["Analytics"],
+					examples: {
+						request: {
+							params: { siteId: "s_01" },
+							query: {
+								startDate: "2026-06-01",
+								endDate: "2026-06-28"
+							}
+						},
+						response: {
+							data: {
+								summary: {
+									totalClicks: 0,
+									attributedClicks: 0,
+									darkClicks: 0,
+									darkPercent: 0,
+									totalImpressions: 0,
+									attributedImpressions: 0
+								},
+								pages: [],
+								meta: {
+									siteUrl: "sc-domain:example.com",
+									syncStatus: "synced"
+								}
+							},
+							meta: {
+								requestId: "req_01",
+								surface: "partner",
+								version: "1.0"
+							}
+						}
+					}
+				}
+			}),
+			getDeviceGap: defineHttpOperation({
+				id: "partner.sites.device.gap.get",
+				method: "GET",
+				path: "/sites/{siteId}/device-gap",
+				visibility: "public",
+				semantics: {
+					kind: "query",
+					sideEffects: "none",
+					idempotent: true,
+					retry: "idempotent",
+					readConsistency: "primary"
+				},
+				auth: {
+					credentials: ["user_key", "partner_key"],
+					scopes: ["analytics:read"],
+					ownership: [{
+						credential: "user_key",
+						rule: "authorized_site"
+					}, {
+						credential: "partner_key",
+						rule: "authorized_site"
+					}]
+				},
+				request: {
+					params: z.strictObject({ siteId: realtimeSchemas.publicSiteId }),
+					query: dateRangeQuery,
+					headers: requestHeaders,
+					body: null
+				},
+				responses: { 200: deviceGapResponse },
+				errors: partnerSiteErrors,
+				errorResponse: errorEnvelopeSchemas(partnerSiteErrors, realtimeSchemas.publicRequestId),
+				resources: {
+					reads: [{
+						type: "site.analytics",
+						idFrom: "params.siteId"
+					}],
+					changes: []
+				},
+				lifecycle: { introduced: "1.2.0" },
+				docs: {
+					summary: "Get desktop/mobile gap",
+					description: "Returns per-day desktop vs mobile CTR/position metrics with gap trends for the window.",
+					tags: ["Analytics"],
+					examples: {
+						request: {
+							params: { siteId: "s_01" },
+							query: {
+								startDate: "2026-06-01",
+								endDate: "2026-06-28"
+							}
+						},
+						response: {
+							data: {
+								daily: [],
+								summary: null,
+								meta: {
+									siteUrl: "sc-domain:example.com",
+									syncStatus: "synced"
+								}
+							},
+							meta: {
+								requestId: "req_01",
+								surface: "partner",
+								version: "1.0"
+							}
+						}
+					}
+				}
+			}),
+			getKeywordBreadth: defineHttpOperation({
+				id: "partner.sites.keyword.breadth.get",
+				method: "GET",
+				path: "/sites/{siteId}/keyword-breadth",
+				visibility: "public",
+				semantics: {
+					kind: "query",
+					sideEffects: "none",
+					idempotent: true,
+					retry: "idempotent",
+					readConsistency: "primary"
+				},
+				auth: {
+					credentials: ["user_key", "partner_key"],
+					scopes: ["analytics:read"],
+					ownership: [{
+						credential: "user_key",
+						rule: "authorized_site"
+					}, {
+						credential: "partner_key",
+						rule: "authorized_site"
+					}]
+				},
+				request: {
+					params: z.strictObject({ siteId: realtimeSchemas.publicSiteId }),
+					query: dateRangeQuery,
+					headers: requestHeaders,
+					body: null
+				},
+				responses: { 200: keywordBreadthResponse },
+				errors: partnerSiteErrors,
+				errorResponse: errorEnvelopeSchemas(partnerSiteErrors, realtimeSchemas.publicRequestId),
+				resources: {
+					reads: [{
+						type: "site.analytics",
+						idFrom: "params.siteId"
+					}],
+					changes: []
+				},
+				lifecycle: { introduced: "1.2.0" },
+				docs: {
+					summary: "Get keyword breadth",
+					description: "Returns the pages-per-keyword-count distribution with fragile and authority page lists for the window.",
+					tags: ["Analytics"],
+					examples: {
+						request: {
+							params: { siteId: "s_01" },
+							query: {
+								startDate: "2026-06-01",
+								endDate: "2026-06-28"
+							}
+						},
+						response: {
+							data: {
+								distribution: [],
+								fragilePages: [],
+								authorityPages: [],
+								summary: {
+									totalPages: 0,
+									avgKeywordsPerPage: 0,
+									fragileCount: 0,
+									authorityCount: 0
+								},
+								meta: {
+									siteUrl: "sc-domain:example.com",
+									syncStatus: "synced"
+								}
+							},
+							meta: {
+								requestId: "req_01",
+								surface: "partner",
+								version: "1.0"
+							}
+						}
+					}
+				}
+			}),
+			getPositionDistribution: defineHttpOperation({
+				id: "partner.sites.position.distribution.get",
+				method: "GET",
+				path: "/sites/{siteId}/position-distribution",
+				visibility: "public",
+				semantics: {
+					kind: "query",
+					sideEffects: "none",
+					idempotent: true,
+					retry: "idempotent",
+					readConsistency: "primary"
+				},
+				auth: {
+					credentials: ["user_key", "partner_key"],
+					scopes: ["analytics:read"],
+					ownership: [{
+						credential: "user_key",
+						rule: "authorized_site"
+					}, {
+						credential: "partner_key",
+						rule: "authorized_site"
+					}]
+				},
+				request: {
+					params: z.strictObject({ siteId: realtimeSchemas.publicSiteId }),
+					query: dateRangeQuery,
+					headers: requestHeaders,
+					body: null
+				},
+				responses: { 200: positionDistributionResponse },
+				errors: partnerSiteErrors,
+				errorResponse: errorEnvelopeSchemas(partnerSiteErrors, realtimeSchemas.publicRequestId),
+				resources: {
+					reads: [{
+						type: "site.analytics",
+						idFrom: "params.siteId"
+					}],
+					changes: []
+				},
+				lifecycle: { introduced: "1.2.0" },
+				docs: {
+					summary: "Get position distribution",
+					description: "Returns the per-day keyword counts bucketed by average position for the window.",
+					tags: ["Analytics"],
+					examples: {
+						request: {
+							params: { siteId: "s_01" },
+							query: {
+								startDate: "2026-06-01",
+								endDate: "2026-06-28"
+							}
+						},
+						response: {
+							data: {
+								distribution: [],
+								meta: {
+									siteUrl: "sc-domain:example.com",
+									syncStatus: "synced"
+								}
+							},
+							meta: {
+								requestId: "req_01",
+								surface: "partner",
+								version: "1.0"
+							}
+						}
+					}
+				}
+			}),
+			getTopAssociation: defineHttpOperation({
+				id: "partner.sites.top.association.get",
+				method: "GET",
+				path: "/sites/{siteId}/top-association",
+				visibility: "public",
+				semantics: {
+					kind: "query",
+					sideEffects: "none",
+					idempotent: true,
+					retry: "idempotent",
+					readConsistency: "primary"
+				},
+				auth: {
+					credentials: ["user_key", "partner_key"],
+					scopes: ["analytics:read"],
+					ownership: [{
+						credential: "user_key",
+						rule: "authorized_site"
+					}, {
+						credential: "partner_key",
+						rule: "authorized_site"
+					}]
+				},
+				request: {
+					params: z.strictObject({ siteId: realtimeSchemas.publicSiteId }),
+					query: topAssociationQuery,
+					headers: requestHeaders,
+					body: null
+				},
+				responses: { 200: topAssociationResponse },
+				errors: partnerSiteErrors,
+				errorResponse: errorEnvelopeSchemas(partnerSiteErrors, realtimeSchemas.publicRequestId),
+				resources: {
+					reads: [{
+						type: "site.analytics",
+						idFrom: "params.siteId"
+					}],
+					changes: []
+				},
+				lifecycle: { introduced: "1.2.0" },
+				docs: {
+					summary: "Get top association",
+					description: "Returns the single best-performing page for a keyword, or keyword for a page, over the window.",
+					tags: ["Analytics"],
+					examples: {
+						request: {
+							params: { siteId: "s_01" },
+							query: {
+								type: "topKeyword",
+								identifier: "/docs",
+								startDate: "2026-06-01",
+								endDate: "2026-06-28"
+							}
+						},
+						response: {
+							data: { value: null },
+							meta: {
+								requestId: "req_01",
+								surface: "partner",
+								version: "1.0"
+							}
+						}
+					}
+				}
+			}),
+			getIndexPercent: defineHttpOperation({
+				id: "partner.sites.index.percent.get",
+				method: "GET",
+				path: "/sites/{siteId}/index-percent",
+				visibility: "public",
+				semantics: {
+					kind: "query",
+					sideEffects: "none",
+					idempotent: true,
+					retry: "idempotent",
+					readConsistency: "primary"
+				},
+				auth: {
+					credentials: ["user_key", "partner_key"],
+					scopes: ["indexing:read"],
+					ownership: [{
+						credential: "user_key",
+						rule: "authorized_site"
+					}, {
+						credential: "partner_key",
+						rule: "authorized_site"
+					}]
+				},
+				request: {
+					params: z.strictObject({ siteId: realtimeSchemas.publicSiteId }),
+					query: indexPercentQuery,
+					headers: requestHeaders,
+					body: null
+				},
+				responses: { 200: indexPercentResponse },
+				errors: partnerSiteErrors,
+				errorResponse: errorEnvelopeSchemas(partnerSiteErrors, realtimeSchemas.publicRequestId),
+				resources: {
+					reads: [{
+						type: "site.indexing",
+						idFrom: "params.siteId"
+					}, {
+						type: "site.sitemaps",
+						idFrom: "params.siteId"
+					}],
+					changes: []
+				},
+				lifecycle: { introduced: "1.2.0" },
+				docs: {
+					summary: "Get sitemap index-percent",
+					description: "Returns the sitemap visibility trend, invisible URLs, orphan pages, and per-sitemap counts.",
+					tags: ["Indexing"],
+					examples: {
+						request: {
+							params: { siteId: "s_01" },
+							query: { invisibleLimit: 100 }
+						},
+						response: {
+							data: {
+								trend: [],
+								invisibleUrls: [],
+								invisibleCount: 0,
+								orphanPages: [],
+								orphanCount: 0,
+								sitemaps: [],
+								summary: {
+									currentPercent: 0,
+									totalSitemapUrls: 0,
+									visibleUrls: 0,
+									change7d: null,
+									change28d: null,
+									dataDate: "2026-06-28"
+								},
+								meta: {
+									siteUrl: "sc-domain:example.com",
+									syncStatus: "synced",
+									newestDateSynced: null
+								}
+							},
+							meta: {
+								requestId: "req_01",
+								surface: "partner",
+								version: "1.0"
+							}
+						}
+					}
+				}
+			}),
+			createSitemapAction: defineHttpOperation({
+				id: "partner.sites.sitemaps.action.create",
+				method: "POST",
+				path: "/sites/{siteId}/sitemaps/actions",
+				visibility: "public",
+				semantics: {
+					kind: "mutation",
+					sideEffects: "state",
+					idempotent: false,
+					retry: "never",
+					readConsistency: null
+				},
+				auth: {
+					credentials: ["user_key", "partner_key"],
+					scopes: ["sitemaps:write"],
+					ownership: [{
+						credential: "user_key",
+						rule: "authorized_site"
+					}, {
+						credential: "partner_key",
+						rule: "authorized_site"
+					}]
+				},
+				request: {
+					params: z.strictObject({ siteId: realtimeSchemas.publicSiteId }),
+					query: null,
+					headers: requestHeaders,
+					body: sitemapActionRequest
+				},
+				responses: { 200: sitemapActionResponse },
+				errors: partnerSiteErrors,
+				errorResponse: errorEnvelopeSchemas(partnerSiteErrors, realtimeSchemas.publicRequestId),
+				resources: {
+					reads: [{
+						type: "site.sitemaps",
+						idFrom: "params.siteId"
+					}],
+					changes: [{
+						type: "site.sitemaps",
+						idFrom: "params.siteId"
+					}]
+				},
+				lifecycle: { introduced: "1.3.0" },
+				docs: {
+					summary: "Run a sitemap action",
+					description: "Submits, deletes, refreshes, or auto-discovers a site's sitemap; the response shape depends on the requested action.",
+					tags: ["Sitemaps"],
+					examples: {
+						request: {
+							params: { siteId: "s_01" },
+							body: { action: "refresh" }
+						},
+						response: {
+							data: {
+								success: true,
+								action: "refreshed",
+								sitemapCount: 0,
+								changed: false
+							},
+							meta: {
+								requestId: "req_01",
+								surface: "partner",
+								version: "1.0"
+							}
+						}
+					}
+				}
+			}),
+			querySitemapMembership: defineHttpOperation({
+				id: "partner.sites.sitemaps.membership.query",
+				method: "POST",
+				path: "/sites/{siteId}/sitemaps/membership",
+				visibility: "public",
+				semantics: {
+					kind: "query",
+					sideEffects: "none",
+					idempotent: true,
+					retry: "idempotent",
+					readConsistency: "primary"
+				},
+				auth: {
+					credentials: ["user_key", "partner_key"],
+					scopes: ["sitemaps:read"],
+					ownership: [{
+						credential: "user_key",
+						rule: "authorized_site"
+					}, {
+						credential: "partner_key",
+						rule: "authorized_site"
+					}]
+				},
+				request: {
+					params: z.strictObject({ siteId: realtimeSchemas.publicSiteId }),
+					query: null,
+					headers: requestHeaders,
+					body: sitemapMembershipRequest
+				},
+				responses: { 200: sitemapMembershipResponse },
+				errors: partnerSiteErrors,
+				errorResponse: errorEnvelopeSchemas(partnerSiteErrors, realtimeSchemas.publicRequestId),
+				resources: {
+					reads: [{
+						type: "site.sitemaps",
+						idFrom: "params.siteId"
+					}],
+					changes: []
+				},
+				lifecycle: { introduced: "1.3.0" },
+				docs: {
+					summary: "Query sitemap membership",
+					description: "Checks whether each requested URL is present in the site's known sitemaps, subject to a freshness cap.",
+					tags: ["Sitemaps"],
+					examples: {
+						request: {
+							params: { siteId: "s_01" },
+							body: {
+								urls: ["https://example.com/"],
+								maxAgeDays: 30
+							}
+						},
+						response: {
+							data: {
+								urls: [],
+								meta: {
+									available: true,
+									reason: null,
+									requested: 1,
+									checked: 1,
+									matched: 0,
+									newestFetchedAt: null
+								}
+							},
+							meta: {
+								requestId: "req_01",
+								surface: "partner",
+								version: "1.0"
+							}
+						}
+					}
+				}
+			}),
+			createTeam: defineHttpOperation({
+				id: "partner.teams.create",
+				method: "POST",
+				path: "/teams",
+				visibility: "public",
+				semantics: {
+					kind: "mutation",
+					sideEffects: "state",
+					idempotent: false,
+					retry: "never",
+					readConsistency: null
+				},
+				auth: {
+					credentials: ["partner_key"],
+					scopes: ["teams:write"],
+					ownership: [{
+						credential: "partner_key",
+						rule: "partner_tenant"
+					}]
+				},
+				request: {
+					params: null,
+					query: null,
+					headers: requestHeaders,
+					body: createTeamRequest
+				},
+				responses: { 200: teamCreatedResponse },
+				errors: partnerUserErrors,
+				errorResponse: errorEnvelopeSchemas(partnerUserErrors, realtimeSchemas.publicRequestId),
+				resources: {
+					reads: [],
+					changes: [{
+						type: "partner.team",
+						idFrom: "principal.id"
+					}]
+				},
+				lifecycle: { introduced: "1.3.0" },
+				docs: {
+					summary: "Create a team",
+					description: "Creates a team owned by a user linked to the authenticated partner tenant.",
+					tags: ["Teams"],
+					examples: {
+						request: { body: {
+							ownerUserId: "u_01",
+							name: "Acme Team"
+						} },
+						response: {
+							data: { team: {
+								id: "t_01",
+								ownerId: 1,
+								name: "Acme Team",
+								personalTeam: false,
+								createdAt: 0,
+								updatedAt: 0
+							} },
+							meta: {
+								requestId: "req_01",
+								surface: "partner",
+								version: "1.0"
+							}
+						}
+					}
+				}
+			}),
+			renameTeam: defineHttpOperation({
+				id: "partner.teams.rename",
+				method: "PATCH",
+				path: "/teams/{teamId}",
+				visibility: "public",
+				semantics: {
+					kind: "mutation",
+					sideEffects: "state",
+					idempotent: true,
+					retry: "idempotent",
+					readConsistency: null
+				},
+				auth: {
+					credentials: ["partner_key"],
+					scopes: ["teams:write"],
+					ownership: [{
+						credential: "partner_key",
+						rule: "partner_tenant"
+					}]
+				},
+				request: {
+					params: z.strictObject({ teamId: realtimeSchemas.publicTeamId }),
+					query: null,
+					headers: requestHeaders,
+					body: renameTeamRequest
+				},
+				responses: { 200: teamRenamedResponse },
+				errors: partnerUserErrors,
+				errorResponse: errorEnvelopeSchemas(partnerUserErrors, realtimeSchemas.publicRequestId),
+				resources: {
+					reads: [{
+						type: "partner.team",
+						idFrom: "params.teamId"
+					}],
+					changes: [{
+						type: "partner.team",
+						idFrom: "params.teamId"
+					}]
+				},
+				lifecycle: { introduced: "1.3.0" },
+				docs: {
+					summary: "Rename a team",
+					description: "Renames a team owned by the authenticated partner tenant.",
+					tags: ["Teams"],
+					examples: {
+						request: {
+							params: { teamId: "t_01" },
+							body: { name: "New name" }
+						},
+						response: {
+							data: {
+								ok: true,
+								name: "New name"
+							},
+							meta: {
+								requestId: "req_01",
+								surface: "partner",
+								version: "1.0"
+							}
+						}
+					}
+				}
+			}),
+			deleteTeam: defineHttpOperation({
+				id: "partner.teams.delete",
+				method: "DELETE",
+				path: "/teams/{teamId}",
+				visibility: "public",
+				semantics: {
+					kind: "mutation",
+					sideEffects: "state",
+					idempotent: true,
+					retry: "idempotent",
+					readConsistency: null
+				},
+				auth: {
+					credentials: ["partner_key"],
+					scopes: ["teams:write"],
+					ownership: [{
+						credential: "partner_key",
+						rule: "partner_tenant"
+					}]
+				},
+				request: {
+					params: z.strictObject({ teamId: realtimeSchemas.publicTeamId }),
+					query: null,
+					headers: requestHeaders,
+					body: null
+				},
+				responses: { 200: teamDeletedResponse },
+				errors: partnerUserErrors,
+				errorResponse: errorEnvelopeSchemas(partnerUserErrors, realtimeSchemas.publicRequestId),
+				resources: {
+					reads: [{
+						type: "partner.team",
+						idFrom: "params.teamId"
+					}],
+					changes: [{
+						type: "partner.team",
+						idFrom: "params.teamId"
+					}]
+				},
+				lifecycle: { introduced: "1.3.0" },
+				docs: {
+					summary: "Delete a team",
+					description: "Deletes a team owned by the authenticated partner tenant.",
+					tags: ["Teams"],
+					examples: {
+						request: { params: { teamId: "t_01" } },
+						response: {
+							data: { ok: true },
+							meta: {
+								requestId: "req_01",
+								surface: "partner",
+								version: "1.0"
+							}
+						}
+					}
+				}
+			}),
+			listTeamMembers: defineHttpOperation({
+				id: "partner.teams.members.list",
+				method: "GET",
+				path: "/teams/{teamId}/members",
+				visibility: "public",
+				semantics: {
+					kind: "query",
+					sideEffects: "none",
+					idempotent: true,
+					retry: "idempotent",
+					readConsistency: "primary"
+				},
+				auth: {
+					credentials: ["partner_key"],
+					scopes: ["teams:read"],
+					ownership: [{
+						credential: "partner_key",
+						rule: "partner_tenant"
+					}]
+				},
+				request: {
+					params: z.strictObject({ teamId: realtimeSchemas.publicTeamId }),
+					query: null,
+					headers: requestHeaders,
+					body: null
+				},
+				responses: { 200: teamMembersResponse },
+				errors: partnerUserErrors,
+				errorResponse: errorEnvelopeSchemas(partnerUserErrors, realtimeSchemas.publicRequestId),
+				resources: {
+					reads: [{
+						type: "partner.team",
+						idFrom: "params.teamId"
+					}],
+					changes: []
+				},
+				lifecycle: { introduced: "1.3.0" },
+				docs: {
+					summary: "List team members",
+					description: "Lists the members of a team owned by the authenticated partner tenant.",
+					tags: ["Teams"],
+					examples: {
+						request: { params: { teamId: "t_01" } },
+						response: {
+							data: { members: [] },
+							meta: {
+								requestId: "req_01",
+								surface: "partner",
+								version: "1.0"
+							}
+						}
+					}
+				}
+			}),
+			addTeamMember: defineHttpOperation({
+				id: "partner.teams.members.add",
+				method: "POST",
+				path: "/teams/{teamId}/members",
+				visibility: "public",
+				semantics: {
+					kind: "mutation",
+					sideEffects: "state",
+					idempotent: true,
+					retry: "idempotent",
+					readConsistency: null
+				},
+				auth: {
+					credentials: ["partner_key"],
+					scopes: ["teams:write"],
+					ownership: [{
+						credential: "partner_key",
+						rule: "partner_tenant"
+					}]
+				},
+				request: {
+					params: z.strictObject({ teamId: realtimeSchemas.publicTeamId }),
+					query: null,
+					headers: requestHeaders,
+					body: addTeamMemberRequest
+				},
+				responses: { 200: teamMemberAddedResponse },
+				errors: partnerUserErrors,
+				errorResponse: errorEnvelopeSchemas(partnerUserErrors, realtimeSchemas.publicRequestId),
+				resources: {
+					reads: [{
+						type: "partner.team",
+						idFrom: "params.teamId"
+					}],
+					changes: [{
+						type: "partner.team",
+						idFrom: "params.teamId"
+					}]
+				},
+				lifecycle: { introduced: "1.3.0" },
+				docs: {
+					summary: "Add a team member",
+					description: "Adds a user to a team owned by the authenticated partner tenant, or reports it was already a member.",
+					tags: ["Teams"],
+					examples: {
+						request: {
+							params: { teamId: "t_01" },
+							body: {
+								userId: "u_02",
+								role: "editor"
+							}
+						},
+						response: {
+							data: {
+								ok: true,
+								role: "editor"
+							},
+							meta: {
+								requestId: "req_01",
+								surface: "partner",
+								version: "1.0"
+							}
+						}
+					}
+				}
+			}),
+			updateTeamMemberRole: defineHttpOperation({
+				id: "partner.teams.members.role.update",
+				method: "PATCH",
+				path: "/teams/{teamId}/members/{userId}",
+				visibility: "public",
+				semantics: {
+					kind: "mutation",
+					sideEffects: "state",
+					idempotent: true,
+					retry: "idempotent",
+					readConsistency: null
+				},
+				auth: {
+					credentials: ["partner_key"],
+					scopes: ["teams:write"],
+					ownership: [{
+						credential: "partner_key",
+						rule: "partner_tenant"
+					}]
+				},
+				request: {
+					params: z.strictObject({
+						teamId: realtimeSchemas.publicTeamId,
+						userId: realtimeSchemas.publicUserId
+					}),
+					query: null,
+					headers: requestHeaders,
+					body: updateTeamMemberRoleRequest
+				},
+				responses: { 200: teamMemberRoleResponse },
+				errors: partnerUserErrors,
+				errorResponse: errorEnvelopeSchemas(partnerUserErrors, realtimeSchemas.publicRequestId),
+				resources: {
+					reads: [{
+						type: "partner.team",
+						idFrom: "params.teamId"
+					}, {
+						type: "partner.user",
+						idFrom: "params.userId"
+					}],
+					changes: [{
+						type: "partner.team",
+						idFrom: "params.teamId"
+					}, {
+						type: "partner.user",
+						idFrom: "params.userId"
+					}]
+				},
+				lifecycle: { introduced: "1.3.0" },
+				docs: {
+					summary: "Update a team member role",
+					description: "Updates the role of an existing member of a team owned by the authenticated partner tenant.",
+					tags: ["Teams"],
+					examples: {
+						request: {
+							params: {
+								teamId: "t_01",
+								userId: "u_02"
+							},
+							body: { role: "admin" }
+						},
+						response: {
+							data: {
+								ok: true,
+								role: "admin"
+							},
+							meta: {
+								requestId: "req_01",
+								surface: "partner",
+								version: "1.0"
+							}
+						}
+					}
+				}
+			}),
+			removeTeamMember: defineHttpOperation({
+				id: "partner.teams.members.remove",
+				method: "DELETE",
+				path: "/teams/{teamId}/members/{userId}",
+				visibility: "public",
+				semantics: {
+					kind: "mutation",
+					sideEffects: "state",
+					idempotent: true,
+					retry: "idempotent",
+					readConsistency: null
+				},
+				auth: {
+					credentials: ["partner_key"],
+					scopes: ["teams:write"],
+					ownership: [{
+						credential: "partner_key",
+						rule: "partner_tenant"
+					}]
+				},
+				request: {
+					params: z.strictObject({
+						teamId: realtimeSchemas.publicTeamId,
+						userId: realtimeSchemas.publicUserId
+					}),
+					query: null,
+					headers: requestHeaders,
+					body: null
+				},
+				responses: { 200: teamMemberRemovedResponse },
+				errors: partnerUserErrors,
+				errorResponse: errorEnvelopeSchemas(partnerUserErrors, realtimeSchemas.publicRequestId),
+				resources: {
+					reads: [{
+						type: "partner.team",
+						idFrom: "params.teamId"
+					}, {
+						type: "partner.user",
+						idFrom: "params.userId"
+					}],
+					changes: [{
+						type: "partner.team",
+						idFrom: "params.teamId"
+					}, {
+						type: "partner.user",
+						idFrom: "params.userId"
+					}]
+				},
+				lifecycle: { introduced: "1.3.0" },
+				docs: {
+					summary: "Remove a team member",
+					description: "Removes a member from a team owned by the authenticated partner tenant.",
+					tags: ["Teams"],
+					examples: {
+						request: { params: {
+							teamId: "t_01",
+							userId: "u_02"
+						} },
+						response: {
+							data: { ok: true },
+							meta: {
+								requestId: "req_01",
+								surface: "partner",
+								version: "1.0"
+							}
+						}
+					}
+				}
+			}),
+			updateSiteTeam: defineHttpOperation({
+				id: "partner.sites.team.update",
+				method: "PATCH",
+				path: "/sites/{siteId}/team",
+				visibility: "public",
+				semantics: {
+					kind: "mutation",
+					sideEffects: "state",
+					idempotent: true,
+					retry: "idempotent",
+					readConsistency: null
+				},
+				auth: {
+					credentials: ["partner_key"],
+					scopes: ["sites:write"],
+					ownership: [{
+						credential: "partner_key",
+						rule: "authorized_site"
+					}]
+				},
+				request: {
+					params: z.strictObject({ siteId: realtimeSchemas.publicSiteId }),
+					query: null,
+					headers: requestHeaders,
+					body: bindSiteTeamRequest
+				},
+				responses: { 200: siteTeamBindingResponse },
+				errors: partnerSiteErrors,
+				errorResponse: errorEnvelopeSchemas(partnerSiteErrors, realtimeSchemas.publicRequestId),
+				resources: {
+					reads: [{
+						type: "site.registration",
+						idFrom: "params.siteId"
+					}],
+					changes: [{
+						type: "site.registration",
+						idFrom: "params.siteId"
+					}]
+				},
+				lifecycle: { introduced: "1.3.0" },
+				docs: {
+					summary: "Bind a site to a team",
+					description: "Binds or unbinds (teamId: null) a partner-owned site to a partner-owned team.",
+					tags: ["Teams"],
+					examples: {
+						request: {
+							params: { siteId: "s_01" },
+							body: { teamId: "t_01" }
+						},
+						response: {
+							data: {
+								ok: true,
+								teamId: "t_01"
+							},
+							meta: {
+								requestId: "req_01",
+								surface: "partner",
+								version: "1.0"
+							}
+						}
+					}
+				}
+			}),
+			getTeamCatalog: defineHttpOperation({
+				id: "partner.teams.catalog.get",
+				method: "GET",
+				path: "/teams/{teamId}/catalog",
+				visibility: "public",
+				semantics: {
+					kind: "query",
+					sideEffects: "none",
+					idempotent: true,
+					retry: "idempotent",
+					readConsistency: "primary"
+				},
+				auth: {
+					credentials: ["partner_key"],
+					scopes: ["teams:read"],
+					ownership: [{
+						credential: "partner_key",
+						rule: "partner_tenant"
+					}]
+				},
+				request: {
+					params: z.strictObject({ teamId: realtimeSchemas.publicTeamId }),
+					query: null,
+					headers: requestHeaders,
+					body: null
+				},
+				responses: { 200: teamCatalogResponse },
+				errors: partnerUserErrors,
+				errorResponse: errorEnvelopeSchemas(partnerUserErrors, realtimeSchemas.publicRequestId),
+				resources: {
+					reads: [{
+						type: "partner.team",
+						idFrom: "params.teamId"
+					}],
+					changes: []
+				},
+				lifecycle: { introduced: "1.3.0" },
+				docs: {
+					summary: "Get a team catalog",
+					description: "Returns the Iceberg catalog reference bound to a partner-owned team, if any.",
+					tags: ["Teams"],
+					examples: {
+						request: { params: { teamId: "t_01" } },
+						response: {
+							data: {
+								teamId: "t_01",
+								catalogUri: null,
+								warehouse: null,
+								bucket: null,
+								namespace: null,
+								provisioningState: null,
+								keyEncoding: null,
+								catalogTablesReady: false,
+								readsEnabled: false
+							},
+							meta: {
+								requestId: "req_01",
+								surface: "partner",
+								version: "1.0"
+							}
+						}
+					}
+				}
+			}),
+			bindTeamCatalog: defineHttpOperation({
+				id: "partner.teams.catalog.bind",
+				method: "POST",
+				path: "/teams/{teamId}/catalog",
+				visibility: "public",
+				semantics: {
+					kind: "mutation",
+					sideEffects: "state",
+					idempotent: true,
+					retry: "idempotent",
+					readConsistency: null
+				},
+				auth: {
+					credentials: ["partner_key"],
+					scopes: ["teams:write"],
+					ownership: [{
+						credential: "partner_key",
+						rule: "partner_tenant"
+					}]
+				},
+				request: {
+					params: z.strictObject({ teamId: realtimeSchemas.publicTeamId }),
+					query: null,
+					headers: requestHeaders,
+					body: bindTeamCatalogRequest
+				},
+				responses: { 200: teamCatalogBindResponse },
+				errors: partnerUserErrors,
+				errorResponse: errorEnvelopeSchemas(partnerUserErrors, realtimeSchemas.publicRequestId),
+				resources: {
+					reads: [{
+						type: "partner.team",
+						idFrom: "params.teamId"
+					}],
+					changes: [{
+						type: "partner.team",
+						idFrom: "params.teamId"
+					}]
+				},
+				lifecycle: { introduced: "1.3.0" },
+				docs: {
+					summary: "Bind a team catalog",
+					description: "Binds an Iceberg catalog (URI, warehouse, and optional bucket/namespace) to a partner-owned team.",
+					tags: ["Teams"],
+					examples: {
+						request: {
+							params: { teamId: "t_01" },
+							body: {
+								catalogUri: "gs://bucket/catalog",
+								warehouse: "primary",
+								namespace: "ns1",
+								bucket: "bucket1"
+							}
+						},
+						response: {
+							data: {
+								teamId: "t_01",
+								status: "ready",
+								catalogUri: "gs://bucket/catalog",
+								warehouse: "primary",
+								bucket: "bucket1",
+								namespace: "ns1"
+							},
+							meta: {
+								requestId: "req_01",
+								surface: "partner",
+								version: "1.0"
+							}
+						}
+					}
+				}
+			}),
+			getSiteIntIdCrosswalk: defineHttpOperation({
+				id: "partner.users.sites.crosswalk.get",
+				method: "GET",
+				path: "/users/{userId}/sites/crosswalk",
+				visibility: "public",
+				semantics: {
+					kind: "query",
+					sideEffects: "none",
+					idempotent: true,
+					retry: "idempotent",
+					readConsistency: "primary"
+				},
+				auth: {
+					credentials: ["user_key", "partner_key"],
+					scopes: ["sites:read"],
+					ownership: [{
+						credential: "user_key",
+						rule: "self"
+					}, {
+						credential: "partner_key",
+						rule: "linked_user"
+					}]
+				},
+				request: {
+					params: z.strictObject({ userId: realtimeSchemas.publicUserId }),
+					query: null,
+					headers: requestHeaders,
+					body: null
+				},
+				responses: { 200: siteIntIdCrosswalkResponse },
+				errors: partnerUserErrors,
+				errorResponse: errorEnvelopeSchemas(partnerUserErrors, realtimeSchemas.publicRequestId),
+				resources: {
+					reads: [{
+						type: "partner.user",
+						idFrom: "params.userId"
+					}, {
+						type: "user.sites",
+						idFrom: "params.userId"
+					}],
+					changes: []
+				},
+				lifecycle: { introduced: "1.3.0" },
+				docs: {
+					summary: "Get the site int-id crosswalk",
+					description: "Maps a user's public site IDs to their internal integer IDs, for partners that need the legacy numeric identifier.",
+					tags: ["Sites"],
+					examples: {
+						request: { params: { userId: "u_01" } },
+						response: {
+							data: {
+								crosswalk: {},
+								sites: []
+							},
+							meta: {
+								requestId: "req_01",
+								surface: "partner",
+								version: "1.0"
+							}
+						}
+					}
+				}
+			}),
+			deleteUser: defineHttpOperation({
+				id: "partner.users.delete",
+				method: "DELETE",
+				path: "/users/{userId}",
+				visibility: "public",
+				semantics: {
+					kind: "mutation",
+					sideEffects: "state",
+					idempotent: true,
+					retry: "idempotent",
+					readConsistency: null
+				},
+				auth: {
+					credentials: ["partner_key"],
+					scopes: ["users:write"],
+					ownership: [{
+						credential: "partner_key",
+						rule: "linked_user"
+					}]
+				},
+				request: {
+					params: z.strictObject({ userId: realtimeSchemas.publicUserId }),
+					query: null,
+					headers: requestHeaders,
+					body: null
+				},
+				responses: { 200: deletePartnerUserResponse },
+				errors: partnerUserErrors,
+				errorResponse: errorEnvelopeSchemas(partnerUserErrors, realtimeSchemas.publicRequestId),
+				resources: {
+					reads: [{
+						type: "partner.user",
+						idFrom: "params.userId"
+					}],
+					changes: [{
+						type: "partner.user",
+						idFrom: "params.userId"
+					}, {
+						type: "user.sites",
+						idFrom: "params.userId"
+					}]
+				},
+				lifecycle: { introduced: "1.3.0" },
+				docs: {
+					summary: "Delete a partner user",
+					description: "Queues cascade deletion of a partner-linked user and their sites.",
+					tags: ["Users"],
+					examples: {
+						request: { params: { userId: "u_01" } },
+						response: {
+							data: {
+								ok: true,
+								queued: true,
+								userId: 1,
+								publicId: "u_01"
+							},
+							meta: {
+								requestId: "req_01",
+								surface: "partner",
+								version: "1.0"
+							}
+						}
+					}
+				}
+			}),
+			createVerificationToken: defineHttpOperation({
+				id: "partner.users.verification.token.create",
+				method: "POST",
+				path: "/users/{userId}/verification-token",
+				visibility: "public",
+				semantics: {
+					kind: "query",
+					sideEffects: "none",
+					idempotent: true,
+					retry: "idempotent",
+					readConsistency: "primary"
+				},
+				auth: {
+					credentials: ["user_key", "partner_key"],
+					scopes: ["sites:write"],
+					ownership: [{
+						credential: "user_key",
+						rule: "self"
+					}, {
+						credential: "partner_key",
+						rule: "linked_user"
+					}]
+				},
+				request: {
+					params: z.strictObject({ userId: realtimeSchemas.publicUserId }),
+					query: null,
+					headers: requestHeaders,
+					body: verificationTokenRequest
+				},
+				responses: { 200: verificationTokenResponse },
+				errors: partnerUserErrors,
+				errorResponse: errorEnvelopeSchemas(partnerUserErrors, realtimeSchemas.publicRequestId),
+				resources: {
+					reads: [{
+						type: "partner.user",
+						idFrom: "params.userId"
+					}, {
+						type: "user.sites",
+						idFrom: "params.userId"
+					}],
+					changes: []
+				},
+				lifecycle: { introduced: "1.3.0" },
+				docs: {
+					summary: "Create a site verification token",
+					description: "Mints a Search Console site-ownership verification token (meta tag or DNS record) for a not-yet-registered site.",
+					tags: ["Sites"],
+					examples: {
+						request: {
+							params: { userId: "u_01" },
+							body: {
+								siteUrl: "https://example.com",
+								method: "DNS_TXT"
+							}
+						},
+						response: {
+							data: {
+								siteUrl: "https://example.com",
+								site: {
+									type: "INET_DOMAIN",
+									identifier: "example.com"
+								},
+								method: "DNS_TXT",
+								token: "abc123",
+								metaContent: null,
+								dnsRecord: {
+									type: "TXT",
+									host: "_gsc.example.com",
+									value: "abc123"
+								}
+							},
+							meta: {
+								requestId: "req_01",
+								surface: "partner",
+								version: "1.0"
+							}
+						}
+					}
+				}
+			}),
+			addAndVerifySite: defineHttpOperation({
+				id: "partner.users.sites.verify.create",
+				method: "POST",
+				path: "/users/{userId}/sites/verify",
+				visibility: "public",
+				semantics: {
+					kind: "mutation",
+					sideEffects: "state",
+					idempotent: true,
+					retry: "idempotent",
+					readConsistency: null
+				},
+				auth: {
+					credentials: ["user_key", "partner_key"],
+					scopes: ["sites:write"],
+					ownership: [{
+						credential: "user_key",
+						rule: "self"
+					}, {
+						credential: "partner_key",
+						rule: "linked_user"
+					}]
+				},
+				request: {
+					params: z.strictObject({ userId: realtimeSchemas.publicUserId }),
+					query: null,
+					headers: requestHeaders,
+					body: addAndVerifySiteRequest
+				},
+				responses: { 200: addAndVerifySiteResponse },
+				errors: partnerUserErrors,
+				errorResponse: errorEnvelopeSchemas(partnerUserErrors, realtimeSchemas.publicRequestId),
+				resources: {
+					reads: [{
+						type: "partner.user",
+						idFrom: "params.userId"
+					}],
+					changes: [{
+						type: "user.sites",
+						idFrom: "params.userId"
+					}]
+				},
+				lifecycle: { introduced: "1.3.0" },
+				docs: {
+					summary: "Add and verify a site",
+					description: "Verifies Search Console ownership of a site for a user via the given method and records the verified ownership.",
+					tags: ["Sites"],
+					examples: {
+						request: {
+							params: { userId: "u_01" },
+							body: {
+								siteUrl: "https://example.com",
+								method: "DNS_TXT"
+							}
+						},
+						response: {
+							data: {
+								siteUrl: "https://example.com",
+								site: {
+									type: "INET_DOMAIN",
+									identifier: "example.com"
+								},
+								method: "DNS_TXT",
+								verified: true,
+								owners: ["owner@example.com"]
+							},
+							meta: {
+								requestId: "req_01",
+								surface: "partner",
+								version: "1.0"
+							}
+						}
+					}
+				}
+			}),
+			queryCrossSource: defineHttpOperation({
+				id: "partner.sites.cross.source.query",
+				method: "POST",
+				path: "/sites/{siteId}/cross-source",
+				visibility: "public",
+				semantics: {
+					kind: "query",
+					sideEffects: "none",
+					idempotent: true,
+					retry: "idempotent",
+					readConsistency: "primary"
+				},
+				auth: {
+					credentials: ["partner_key"],
+					scopes: ["analytics:read"],
+					ownership: [{
+						credential: "partner_key",
+						rule: "authorized_site"
+					}]
+				},
+				request: {
+					params: z.strictObject({ siteId: realtimeSchemas.publicSiteId }),
+					query: null,
+					headers: requestHeaders,
+					body: crossSourceRequest
+				},
+				responses: { 200: crossSourceResponse },
+				errors: partnerSiteErrors,
+				errorResponse: errorEnvelopeSchemas(partnerSiteErrors, realtimeSchemas.publicRequestId),
+				resources: {
+					reads: [{
+						type: "site.analytics",
+						idFrom: "params.siteId"
+					}],
+					changes: []
+				},
+				lifecycle: { introduced: "1.3.0" },
+				docs: {
+					summary: "Query cross-source analysis",
+					description: "Runs one predefined cross-source query joining crawl, CWV, and GSC signals for a site.",
+					tags: ["Analytics"],
+					examples: {
+						request: {
+							params: { siteId: "s_01" },
+							body: {
+								queryKey: "crawl-error-losing-impressions",
+								rangeDays: 28,
+								limit: 50
+							}
+						},
+						response: {
+							data: {
+								sources: ["crawl", "gsc"],
+								rows: []
+							},
+							meta: {
+								requestId: "req_01",
+								surface: "partner",
+								version: "1.0"
+							}
+						}
+					}
+				}
+			}),
+			enrichKeywords: defineHttpOperation({
+				id: "partner.keywords.enrich.query",
+				method: "POST",
+				path: "/keywords/enrich",
+				visibility: "public",
+				semantics: {
+					kind: "query",
+					sideEffects: "none",
+					idempotent: true,
+					retry: "idempotent",
+					readConsistency: "primary"
+				},
+				auth: {
+					credentials: ["user_key", "partner_key"],
+					scopes: ["analytics:read"],
+					ownership: [{
+						credential: "user_key",
+						rule: "self"
+					}, {
+						credential: "partner_key",
+						rule: "partner_tenant"
+					}]
+				},
+				request: {
+					params: null,
+					query: null,
+					headers: requestHeaders,
+					body: enrichKeywordsRequest
+				},
+				responses: { 200: enrichKeywordsResponse },
+				errors: partnerUserErrors,
+				errorResponse: errorEnvelopeSchemas(partnerUserErrors, realtimeSchemas.publicRequestId),
+				resources: {
+					reads: [],
+					changes: []
+				},
+				lifecycle: { introduced: "1.3.0" },
+				docs: {
+					summary: "Enrich keywords with metrics",
+					description: "Returns difficulty, search volume, and CPC estimates for up to 500 keywords.",
+					tags: ["Analytics"],
+					examples: {
+						request: { body: { keywords: ["nuxt seo"] } },
+						response: {
+							data: { metrics: { "nuxt seo": {
+								difficulty: 40,
+								searchVolume: 100,
+								cpc: 1.2
+							} } },
+							meta: {
+								requestId: "req_01",
+								surface: "partner",
+								version: "1.0"
+							}
+						}
+					}
+				}
 			})
 		}
 	});