@gscdump/contracts 1.2.0 → 1.3.1

package/dist/v1/index.d.mts

@@ -8160,6 +8160,2607 @@ declare function createGscdumpV1Protocol(): {
           };
         };
       };
+      readonly createSitemapAction: {
+        readonly id: "partner.sites.sitemaps.action.create";
+        readonly method: "POST";
+        readonly path: "/sites/{siteId}/sitemaps/actions";
+        readonly visibility: "public";
+        readonly semantics: {
+          readonly kind: "mutation";
+          readonly sideEffects: "state";
+          readonly idempotent: false;
+          readonly retry: "never";
+          readonly readConsistency: null;
+        };
+        readonly auth: {
+          readonly credentials: readonly ["user_key", "partner_key"];
+          readonly scopes: readonly ["sitemaps:write"];
+          readonly ownership: readonly [{
+            readonly credential: "user_key";
+            readonly rule: "authorized_site";
+          }, {
+            readonly credential: "partner_key";
+            readonly rule: "authorized_site";
+          }];
+        };
+        readonly request: {
+          readonly params: z.ZodObject<{
+            siteId: z.ZodString;
+          }, z.core.$strict>;
+          readonly query: null;
+          readonly headers: z.ZodObject<{
+            'x-request-id': z.ZodOptional<z.ZodString>;
+          }, z.core.$strict>;
+          readonly body: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            action: z.ZodLiteral<"submit">;
+            sitemapUrl: z.ZodString;
+          }, z.core.$strip>, z.ZodObject<{
+            action: z.ZodLiteral<"delete">;
+            sitemapUrl: z.ZodString;
+          }, z.core.$strip>, z.ZodObject<{
+            action: z.ZodLiteral<"refresh">;
+          }, z.core.$strip>, z.ZodObject<{
+            action: z.ZodLiteral<"auto-discover">;
+          }, z.core.$strip>], "action">;
+        };
+        readonly responses: {
+          readonly 200: CompatibleResponseSchema<z.ZodObject<{
+            data: z.ZodDiscriminatedUnion<[z.ZodObject<{
+              success: z.ZodBoolean;
+              action: z.ZodEnum<{
+                submitted: "submitted";
+                deleted: "deleted";
+              }>;
+              sitemapUrl: z.ZodString;
+              sitemapCount: z.ZodNumber;
+            }, z.core.$loose>, z.ZodObject<{
+              success: z.ZodLiteral<true>;
+              action: z.ZodLiteral<"refreshed">;
+              sitemapCount: z.ZodNumber;
+              changed: z.ZodBoolean;
+            }, z.core.$loose>, z.ZodObject<{
+              success: z.ZodBoolean;
+              action: z.ZodLiteral<"auto-discover">;
+              discovered: z.ZodNullable<z.ZodString>;
+              submitError: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+              sitemapCount: z.ZodNumber;
+            }, z.core.$loose>], "action">;
+            meta: z.ZodObject<{
+              readonly requestId: z.ZodString;
+              readonly surface: z.ZodLiteral<"partner">;
+              readonly version: z.ZodLiteral<"1.0">;
+            }, z.core.$strip>;
+          }, z.core.$strip>, z.ZodObject<{
+            data: z.ZodDiscriminatedUnion<[z.ZodObject<{
+              success: z.ZodBoolean;
+              action: z.ZodEnum<{
+                submitted: "submitted";
+                deleted: "deleted";
+              }>;
+              sitemapUrl: z.ZodString;
+              sitemapCount: z.ZodNumber;
+            }, z.core.$loose>, z.ZodObject<{
+              success: z.ZodLiteral<true>;
+              action: z.ZodLiteral<"refreshed">;
+              sitemapCount: z.ZodNumber;
+              changed: z.ZodBoolean;
+            }, z.core.$loose>, z.ZodObject<{
+              success: z.ZodBoolean;
+              action: z.ZodLiteral<"auto-discover">;
+              discovered: z.ZodNullable<z.ZodString>;
+              submitError: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+              sitemapCount: z.ZodNumber;
+            }, z.core.$loose>], "action">;
+            meta: z.ZodObject<{
+              readonly requestId: z.ZodString;
+              readonly surface: z.ZodLiteral<"partner">;
+              readonly version: z.ZodLiteral<"1.0">;
+            }, z.core.$strip>;
+          }, z.core.$strip>>;
+        };
+        readonly errors: readonly ["invalid_request", "unauthorized", "forbidden", "site_not_found", "rate_limited", "internal_error", "contract_violation"];
+        readonly errorResponse: CompatibleResponseSchema<z.ZodObject<{
+          readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+              rate_limited: "rate_limited";
+              internal_error: "internal_error";
+              invalid_request: "invalid_request";
+              unauthorized: "unauthorized";
+              forbidden: "forbidden";
+              site_not_found: "site_not_found";
+              contract_violation: "contract_violation";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+          }, z.core.$strict>;
+        }, z.core.$strip>, z.ZodObject<{
+          readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+              rate_limited: "rate_limited";
+              internal_error: "internal_error";
+              invalid_request: "invalid_request";
+              unauthorized: "unauthorized";
+              forbidden: "forbidden";
+              site_not_found: "site_not_found";
+              contract_violation: "contract_violation";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+          }, z.core.$loose>;
+        }, z.core.$strip>>;
+        readonly resources: {
+          readonly reads: readonly [{
+            readonly type: "site.sitemaps";
+            readonly idFrom: "params.siteId";
+          }];
+          readonly changes: readonly [{
+            readonly type: "site.sitemaps";
+            readonly idFrom: "params.siteId";
+          }];
+        };
+        readonly lifecycle: {
+          readonly introduced: "1.3.0";
+        };
+        readonly docs: {
+          readonly summary: "Run a sitemap action";
+          readonly description: "Submits, deletes, refreshes, or auto-discovers a site's sitemap; the response shape depends on the requested action.";
+          readonly tags: readonly ["Sitemaps"];
+          readonly examples: {
+            readonly request: {
+              readonly params: {
+                readonly siteId: "s_01";
+              };
+              readonly body: {
+                readonly action: "refresh";
+              };
+            };
+            readonly response: {
+              readonly data: {
+                readonly success: true;
+                readonly action: "refreshed";
+                readonly sitemapCount: 0;
+                readonly changed: false;
+              };
+              readonly meta: {
+                readonly requestId: "req_01";
+                readonly surface: "partner";
+                readonly version: "1.0";
+              };
+            };
+          };
+        };
+      };
+      readonly querySitemapMembership: {
+        readonly id: "partner.sites.sitemaps.membership.query";
+        readonly method: "POST";
+        readonly path: "/sites/{siteId}/sitemaps/membership";
+        readonly visibility: "public";
+        readonly semantics: {
+          readonly kind: "query";
+          readonly sideEffects: "none";
+          readonly idempotent: true;
+          readonly retry: "idempotent";
+          readonly readConsistency: "primary";
+        };
+        readonly auth: {
+          readonly credentials: readonly ["user_key", "partner_key"];
+          readonly scopes: readonly ["sitemaps:read"];
+          readonly ownership: readonly [{
+            readonly credential: "user_key";
+            readonly rule: "authorized_site";
+          }, {
+            readonly credential: "partner_key";
+            readonly rule: "authorized_site";
+          }];
+        };
+        readonly request: {
+          readonly params: z.ZodObject<{
+            siteId: z.ZodString;
+          }, z.core.$strict>;
+          readonly query: null;
+          readonly headers: z.ZodObject<{
+            'x-request-id': z.ZodOptional<z.ZodString>;
+          }, z.core.$strict>;
+          readonly body: z.ZodObject<{
+            urls: z.ZodArray<z.ZodString>;
+            maxAgeDays: z.ZodOptional<z.ZodNumber>;
+          }, z.core.$strict>;
+        };
+        readonly responses: {
+          readonly 200: CompatibleResponseSchema<z.ZodObject<{
+            data: z.ZodObject<{
+              urls: z.ZodArray<z.ZodObject<{
+                url: z.ZodString;
+                normalized: z.ZodString;
+                inSitemap: z.ZodBoolean;
+                sitemapUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                lastSeenAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                lastmod: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                sitemapFetchedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+              }, z.core.$loose>>;
+              meta: z.ZodObject<{
+                available: z.ZodBoolean;
+                reason: z.ZodNullable<z.ZodEnum<{
+                  empty: "empty";
+                  site_url_cap_exceeded: "site_url_cap_exceeded";
+                  stale_sitemaps: "stale_sitemaps";
+                }>>;
+                requested: z.ZodNumber;
+                checked: z.ZodNumber;
+                matched: z.ZodNumber;
+                newestFetchedAt: z.ZodNullable<z.ZodString>;
+              }, z.core.$loose>;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+              readonly requestId: z.ZodString;
+              readonly surface: z.ZodLiteral<"partner">;
+              readonly version: z.ZodLiteral<"1.0">;
+            }, z.core.$strip>;
+          }, z.core.$strip>, z.ZodObject<{
+            data: z.ZodObject<{
+              urls: z.ZodArray<z.ZodObject<{
+                url: z.ZodString;
+                normalized: z.ZodString;
+                inSitemap: z.ZodBoolean;
+                sitemapUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                lastSeenAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                lastmod: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                sitemapFetchedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+              }, z.core.$loose>>;
+              meta: z.ZodObject<{
+                available: z.ZodBoolean;
+                reason: z.ZodNullable<z.ZodEnum<{
+                  empty: "empty";
+                  site_url_cap_exceeded: "site_url_cap_exceeded";
+                  stale_sitemaps: "stale_sitemaps";
+                }>>;
+                requested: z.ZodNumber;
+                checked: z.ZodNumber;
+                matched: z.ZodNumber;
+                newestFetchedAt: z.ZodNullable<z.ZodString>;
+              }, z.core.$loose>;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+              readonly requestId: z.ZodString;
+              readonly surface: z.ZodLiteral<"partner">;
+              readonly version: z.ZodLiteral<"1.0">;
+            }, z.core.$strip>;
+          }, z.core.$strip>>;
+        };
+        readonly errors: readonly ["invalid_request", "unauthorized", "forbidden", "site_not_found", "rate_limited", "internal_error", "contract_violation"];
+        readonly errorResponse: CompatibleResponseSchema<z.ZodObject<{
+          readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+              rate_limited: "rate_limited";
+              internal_error: "internal_error";
+              invalid_request: "invalid_request";
+              unauthorized: "unauthorized";
+              forbidden: "forbidden";
+              site_not_found: "site_not_found";
+              contract_violation: "contract_violation";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+          }, z.core.$strict>;
+        }, z.core.$strip>, z.ZodObject<{
+          readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+              rate_limited: "rate_limited";
+              internal_error: "internal_error";
+              invalid_request: "invalid_request";
+              unauthorized: "unauthorized";
+              forbidden: "forbidden";
+              site_not_found: "site_not_found";
+              contract_violation: "contract_violation";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+          }, z.core.$loose>;
+        }, z.core.$strip>>;
+        readonly resources: {
+          readonly reads: readonly [{
+            readonly type: "site.sitemaps";
+            readonly idFrom: "params.siteId";
+          }];
+          readonly changes: readonly [];
+        };
+        readonly lifecycle: {
+          readonly introduced: "1.3.0";
+        };
+        readonly docs: {
+          readonly summary: "Query sitemap membership";
+          readonly description: "Checks whether each requested URL is present in the site's known sitemaps, subject to a freshness cap.";
+          readonly tags: readonly ["Sitemaps"];
+          readonly examples: {
+            readonly request: {
+              readonly params: {
+                readonly siteId: "s_01";
+              };
+              readonly body: {
+                readonly urls: readonly ["https://example.com/"];
+                readonly maxAgeDays: 30;
+              };
+            };
+            readonly response: {
+              readonly data: {
+                readonly urls: readonly [];
+                readonly meta: {
+                  readonly available: true;
+                  readonly reason: null;
+                  readonly requested: 1;
+                  readonly checked: 1;
+                  readonly matched: 0;
+                  readonly newestFetchedAt: null;
+                };
+              };
+              readonly meta: {
+                readonly requestId: "req_01";
+                readonly surface: "partner";
+                readonly version: "1.0";
+              };
+            };
+          };
+        };
+      };
+      readonly createTeam: {
+        readonly id: "partner.teams.create";
+        readonly method: "POST";
+        readonly path: "/teams";
+        readonly visibility: "public";
+        readonly semantics: {
+          readonly kind: "mutation";
+          readonly sideEffects: "state";
+          readonly idempotent: false;
+          readonly retry: "never";
+          readonly readConsistency: null;
+        };
+        readonly auth: {
+          readonly credentials: readonly ["partner_key"];
+          readonly scopes: readonly ["teams:write"];
+          readonly ownership: readonly [{
+            readonly credential: "partner_key";
+            readonly rule: "partner_tenant";
+          }];
+        };
+        readonly request: {
+          readonly params: null;
+          readonly query: null;
+          readonly headers: z.ZodObject<{
+            'x-request-id': z.ZodOptional<z.ZodString>;
+          }, z.core.$strict>;
+          readonly body: z.ZodObject<{
+            ownerUserId: z.ZodString;
+            name: z.ZodString;
+            personalTeam: z.ZodOptional<z.ZodBoolean>;
+          }, z.core.$strict>;
+        };
+        readonly responses: {
+          readonly 200: CompatibleResponseSchema<z.ZodObject<{
+            data: z.ZodObject<{
+              team: z.ZodObject<{
+                id: z.ZodString;
+                ownerId: z.ZodNumber;
+                name: z.ZodString;
+                personalTeam: z.ZodBoolean;
+                createdAt: z.ZodNumber;
+                updatedAt: z.ZodNumber;
+              }, z.core.$loose>;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+              readonly requestId: z.ZodString;
+              readonly surface: z.ZodLiteral<"partner">;
+              readonly version: z.ZodLiteral<"1.0">;
+            }, z.core.$strip>;
+          }, z.core.$strip>, z.ZodObject<{
+            data: z.ZodObject<{
+              team: z.ZodObject<{
+                id: z.ZodString;
+                ownerId: z.ZodNumber;
+                name: z.ZodString;
+                personalTeam: z.ZodBoolean;
+                createdAt: z.ZodNumber;
+                updatedAt: z.ZodNumber;
+              }, z.core.$loose>;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+              readonly requestId: z.ZodString;
+              readonly surface: z.ZodLiteral<"partner">;
+              readonly version: z.ZodLiteral<"1.0">;
+            }, z.core.$strip>;
+          }, z.core.$strip>>;
+        };
+        readonly errors: readonly ["invalid_request", "unauthorized", "forbidden", "user_not_found", "rate_limited", "internal_error", "contract_violation"];
+        readonly errorResponse: CompatibleResponseSchema<z.ZodObject<{
+          readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+              rate_limited: "rate_limited";
+              internal_error: "internal_error";
+              invalid_request: "invalid_request";
+              unauthorized: "unauthorized";
+              forbidden: "forbidden";
+              user_not_found: "user_not_found";
+              contract_violation: "contract_violation";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+          }, z.core.$strict>;
+        }, z.core.$strip>, z.ZodObject<{
+          readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+              rate_limited: "rate_limited";
+              internal_error: "internal_error";
+              invalid_request: "invalid_request";
+              unauthorized: "unauthorized";
+              forbidden: "forbidden";
+              user_not_found: "user_not_found";
+              contract_violation: "contract_violation";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+          }, z.core.$loose>;
+        }, z.core.$strip>>;
+        readonly resources: {
+          readonly reads: readonly [];
+          readonly changes: readonly [{
+            readonly type: "partner.team";
+            readonly idFrom: "principal.id";
+          }];
+        };
+        readonly lifecycle: {
+          readonly introduced: "1.3.0";
+        };
+        readonly docs: {
+          readonly summary: "Create a team";
+          readonly description: "Creates a team owned by a user linked to the authenticated partner tenant.";
+          readonly tags: readonly ["Teams"];
+          readonly examples: {
+            readonly request: {
+              readonly body: {
+                readonly ownerUserId: "u_01";
+                readonly name: "Acme Team";
+              };
+            };
+            readonly response: {
+              readonly data: {
+                readonly team: {
+                  readonly id: "t_01";
+                  readonly ownerId: 1;
+                  readonly name: "Acme Team";
+                  readonly personalTeam: false;
+                  readonly createdAt: 0;
+                  readonly updatedAt: 0;
+                };
+              };
+              readonly meta: {
+                readonly requestId: "req_01";
+                readonly surface: "partner";
+                readonly version: "1.0";
+              };
+            };
+          };
+        };
+      };
+      readonly renameTeam: {
+        readonly id: "partner.teams.rename";
+        readonly method: "PATCH";
+        readonly path: "/teams/{teamId}";
+        readonly visibility: "public";
+        readonly semantics: {
+          readonly kind: "mutation";
+          readonly sideEffects: "state";
+          readonly idempotent: true;
+          readonly retry: "idempotent";
+          readonly readConsistency: null;
+        };
+        readonly auth: {
+          readonly credentials: readonly ["partner_key"];
+          readonly scopes: readonly ["teams:write"];
+          readonly ownership: readonly [{
+            readonly credential: "partner_key";
+            readonly rule: "partner_tenant";
+          }];
+        };
+        readonly request: {
+          readonly params: z.ZodObject<{
+            teamId: z.ZodString;
+          }, z.core.$strict>;
+          readonly query: null;
+          readonly headers: z.ZodObject<{
+            'x-request-id': z.ZodOptional<z.ZodString>;
+          }, z.core.$strict>;
+          readonly body: z.ZodObject<{
+            name: z.ZodString;
+          }, z.core.$strict>;
+        };
+        readonly responses: {
+          readonly 200: CompatibleResponseSchema<z.ZodObject<{
+            data: z.ZodObject<{
+              ok: z.ZodLiteral<true>;
+              name: z.ZodString;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+              readonly requestId: z.ZodString;
+              readonly surface: z.ZodLiteral<"partner">;
+              readonly version: z.ZodLiteral<"1.0">;
+            }, z.core.$strip>;
+          }, z.core.$strip>, z.ZodObject<{
+            data: z.ZodObject<{
+              ok: z.ZodLiteral<true>;
+              name: z.ZodString;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+              readonly requestId: z.ZodString;
+              readonly surface: z.ZodLiteral<"partner">;
+              readonly version: z.ZodLiteral<"1.0">;
+            }, z.core.$strip>;
+          }, z.core.$strip>>;
+        };
+        readonly errors: readonly ["invalid_request", "unauthorized", "forbidden", "user_not_found", "rate_limited", "internal_error", "contract_violation"];
+        readonly errorResponse: CompatibleResponseSchema<z.ZodObject<{
+          readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+              rate_limited: "rate_limited";
+              internal_error: "internal_error";
+              invalid_request: "invalid_request";
+              unauthorized: "unauthorized";
+              forbidden: "forbidden";
+              user_not_found: "user_not_found";
+              contract_violation: "contract_violation";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+          }, z.core.$strict>;
+        }, z.core.$strip>, z.ZodObject<{
+          readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+              rate_limited: "rate_limited";
+              internal_error: "internal_error";
+              invalid_request: "invalid_request";
+              unauthorized: "unauthorized";
+              forbidden: "forbidden";
+              user_not_found: "user_not_found";
+              contract_violation: "contract_violation";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+          }, z.core.$loose>;
+        }, z.core.$strip>>;
+        readonly resources: {
+          readonly reads: readonly [{
+            readonly type: "partner.team";
+            readonly idFrom: "params.teamId";
+          }];
+          readonly changes: readonly [{
+            readonly type: "partner.team";
+            readonly idFrom: "params.teamId";
+          }];
+        };
+        readonly lifecycle: {
+          readonly introduced: "1.3.0";
+        };
+        readonly docs: {
+          readonly summary: "Rename a team";
+          readonly description: "Renames a team owned by the authenticated partner tenant.";
+          readonly tags: readonly ["Teams"];
+          readonly examples: {
+            readonly request: {
+              readonly params: {
+                readonly teamId: "t_01";
+              };
+              readonly body: {
+                readonly name: "New name";
+              };
+            };
+            readonly response: {
+              readonly data: {
+                readonly ok: true;
+                readonly name: "New name";
+              };
+              readonly meta: {
+                readonly requestId: "req_01";
+                readonly surface: "partner";
+                readonly version: "1.0";
+              };
+            };
+          };
+        };
+      };
+      readonly deleteTeam: {
+        readonly id: "partner.teams.delete";
+        readonly method: "DELETE";
+        readonly path: "/teams/{teamId}";
+        readonly visibility: "public";
+        readonly semantics: {
+          readonly kind: "mutation";
+          readonly sideEffects: "state";
+          readonly idempotent: true;
+          readonly retry: "idempotent";
+          readonly readConsistency: null;
+        };
+        readonly auth: {
+          readonly credentials: readonly ["partner_key"];
+          readonly scopes: readonly ["teams:write"];
+          readonly ownership: readonly [{
+            readonly credential: "partner_key";
+            readonly rule: "partner_tenant";
+          }];
+        };
+        readonly request: {
+          readonly params: z.ZodObject<{
+            teamId: z.ZodString;
+          }, z.core.$strict>;
+          readonly query: null;
+          readonly headers: z.ZodObject<{
+            'x-request-id': z.ZodOptional<z.ZodString>;
+          }, z.core.$strict>;
+          readonly body: null;
+        };
+        readonly responses: {
+          readonly 200: CompatibleResponseSchema<z.ZodObject<{
+            data: z.ZodObject<{
+              ok: z.ZodLiteral<true>;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+              readonly requestId: z.ZodString;
+              readonly surface: z.ZodLiteral<"partner">;
+              readonly version: z.ZodLiteral<"1.0">;
+            }, z.core.$strip>;
+          }, z.core.$strip>, z.ZodObject<{
+            data: z.ZodObject<{
+              ok: z.ZodLiteral<true>;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+              readonly requestId: z.ZodString;
+              readonly surface: z.ZodLiteral<"partner">;
+              readonly version: z.ZodLiteral<"1.0">;
+            }, z.core.$strip>;
+          }, z.core.$strip>>;
+        };
+        readonly errors: readonly ["invalid_request", "unauthorized", "forbidden", "user_not_found", "rate_limited", "internal_error", "contract_violation"];
+        readonly errorResponse: CompatibleResponseSchema<z.ZodObject<{
+          readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+              rate_limited: "rate_limited";
+              internal_error: "internal_error";
+              invalid_request: "invalid_request";
+              unauthorized: "unauthorized";
+              forbidden: "forbidden";
+              user_not_found: "user_not_found";
+              contract_violation: "contract_violation";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+          }, z.core.$strict>;
+        }, z.core.$strip>, z.ZodObject<{
+          readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+              rate_limited: "rate_limited";
+              internal_error: "internal_error";
+              invalid_request: "invalid_request";
+              unauthorized: "unauthorized";
+              forbidden: "forbidden";
+              user_not_found: "user_not_found";
+              contract_violation: "contract_violation";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+          }, z.core.$loose>;
+        }, z.core.$strip>>;
+        readonly resources: {
+          readonly reads: readonly [{
+            readonly type: "partner.team";
+            readonly idFrom: "params.teamId";
+          }];
+          readonly changes: readonly [{
+            readonly type: "partner.team";
+            readonly idFrom: "params.teamId";
+          }];
+        };
+        readonly lifecycle: {
+          readonly introduced: "1.3.0";
+        };
+        readonly docs: {
+          readonly summary: "Delete a team";
+          readonly description: "Deletes a team owned by the authenticated partner tenant.";
+          readonly tags: readonly ["Teams"];
+          readonly examples: {
+            readonly request: {
+              readonly params: {
+                readonly teamId: "t_01";
+              };
+            };
+            readonly response: {
+              readonly data: {
+                readonly ok: true;
+              };
+              readonly meta: {
+                readonly requestId: "req_01";
+                readonly surface: "partner";
+                readonly version: "1.0";
+              };
+            };
+          };
+        };
+      };
+      readonly listTeamMembers: {
+        readonly id: "partner.teams.members.list";
+        readonly method: "GET";
+        readonly path: "/teams/{teamId}/members";
+        readonly visibility: "public";
+        readonly semantics: {
+          readonly kind: "query";
+          readonly sideEffects: "none";
+          readonly idempotent: true;
+          readonly retry: "idempotent";
+          readonly readConsistency: "primary";
+        };
+        readonly auth: {
+          readonly credentials: readonly ["partner_key"];
+          readonly scopes: readonly ["teams:read"];
+          readonly ownership: readonly [{
+            readonly credential: "partner_key";
+            readonly rule: "partner_tenant";
+          }];
+        };
+        readonly request: {
+          readonly params: z.ZodObject<{
+            teamId: z.ZodString;
+          }, z.core.$strict>;
+          readonly query: null;
+          readonly headers: z.ZodObject<{
+            'x-request-id': z.ZodOptional<z.ZodString>;
+          }, z.core.$strict>;
+          readonly body: null;
+        };
+        readonly responses: {
+          readonly 200: CompatibleResponseSchema<z.ZodObject<{
+            data: z.ZodObject<{
+              members: z.ZodArray<z.ZodObject<{
+                userId: z.ZodNumber;
+                publicId: z.ZodString;
+                name: z.ZodNullable<z.ZodString>;
+                email: z.ZodEmail;
+                picture: z.ZodNullable<z.ZodString>;
+                role: z.ZodEnum<{
+                  admin: "admin";
+                  editor: "editor";
+                  viewer: "viewer";
+                }>;
+                joinedAt: z.ZodNumber;
+              }, z.core.$loose>>;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+              readonly requestId: z.ZodString;
+              readonly surface: z.ZodLiteral<"partner">;
+              readonly version: z.ZodLiteral<"1.0">;
+            }, z.core.$strip>;
+          }, z.core.$strip>, z.ZodObject<{
+            data: z.ZodObject<{
+              members: z.ZodArray<z.ZodObject<{
+                userId: z.ZodNumber;
+                publicId: z.ZodString;
+                name: z.ZodNullable<z.ZodString>;
+                email: z.ZodEmail;
+                picture: z.ZodNullable<z.ZodString>;
+                role: z.ZodEnum<{
+                  admin: "admin";
+                  editor: "editor";
+                  viewer: "viewer";
+                }>;
+                joinedAt: z.ZodNumber;
+              }, z.core.$loose>>;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+              readonly requestId: z.ZodString;
+              readonly surface: z.ZodLiteral<"partner">;
+              readonly version: z.ZodLiteral<"1.0">;
+            }, z.core.$strip>;
+          }, z.core.$strip>>;
+        };
+        readonly errors: readonly ["invalid_request", "unauthorized", "forbidden", "user_not_found", "rate_limited", "internal_error", "contract_violation"];
+        readonly errorResponse: CompatibleResponseSchema<z.ZodObject<{
+          readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+              rate_limited: "rate_limited";
+              internal_error: "internal_error";
+              invalid_request: "invalid_request";
+              unauthorized: "unauthorized";
+              forbidden: "forbidden";
+              user_not_found: "user_not_found";
+              contract_violation: "contract_violation";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+          }, z.core.$strict>;
+        }, z.core.$strip>, z.ZodObject<{
+          readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+              rate_limited: "rate_limited";
+              internal_error: "internal_error";
+              invalid_request: "invalid_request";
+              unauthorized: "unauthorized";
+              forbidden: "forbidden";
+              user_not_found: "user_not_found";
+              contract_violation: "contract_violation";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+          }, z.core.$loose>;
+        }, z.core.$strip>>;
+        readonly resources: {
+          readonly reads: readonly [{
+            readonly type: "partner.team";
+            readonly idFrom: "params.teamId";
+          }];
+          readonly changes: readonly [];
+        };
+        readonly lifecycle: {
+          readonly introduced: "1.3.0";
+        };
+        readonly docs: {
+          readonly summary: "List team members";
+          readonly description: "Lists the members of a team owned by the authenticated partner tenant.";
+          readonly tags: readonly ["Teams"];
+          readonly examples: {
+            readonly request: {
+              readonly params: {
+                readonly teamId: "t_01";
+              };
+            };
+            readonly response: {
+              readonly data: {
+                readonly members: readonly [];
+              };
+              readonly meta: {
+                readonly requestId: "req_01";
+                readonly surface: "partner";
+                readonly version: "1.0";
+              };
+            };
+          };
+        };
+      };
+      readonly addTeamMember: {
+        readonly id: "partner.teams.members.add";
+        readonly method: "POST";
+        readonly path: "/teams/{teamId}/members";
+        readonly visibility: "public";
+        readonly semantics: {
+          readonly kind: "mutation";
+          readonly sideEffects: "state";
+          readonly idempotent: true;
+          readonly retry: "idempotent";
+          readonly readConsistency: null;
+        };
+        readonly auth: {
+          readonly credentials: readonly ["partner_key"];
+          readonly scopes: readonly ["teams:write"];
+          readonly ownership: readonly [{
+            readonly credential: "partner_key";
+            readonly rule: "partner_tenant";
+          }];
+        };
+        readonly request: {
+          readonly params: z.ZodObject<{
+            teamId: z.ZodString;
+          }, z.core.$strict>;
+          readonly query: null;
+          readonly headers: z.ZodObject<{
+            'x-request-id': z.ZodOptional<z.ZodString>;
+          }, z.core.$strict>;
+          readonly body: z.ZodObject<{
+            userId: z.ZodString;
+            role: z.ZodEnum<{
+              admin: "admin";
+              editor: "editor";
+              viewer: "viewer";
+            }>;
+          }, z.core.$strict>;
+        };
+        readonly responses: {
+          readonly 200: CompatibleResponseSchema<z.ZodObject<{
+            data: z.ZodObject<{
+              ok: z.ZodLiteral<true>;
+              role: z.ZodEnum<{
+                admin: "admin";
+                editor: "editor";
+                viewer: "viewer";
+              }>;
+              alreadyExisted: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+              readonly requestId: z.ZodString;
+              readonly surface: z.ZodLiteral<"partner">;
+              readonly version: z.ZodLiteral<"1.0">;
+            }, z.core.$strip>;
+          }, z.core.$strip>, z.ZodObject<{
+            data: z.ZodObject<{
+              ok: z.ZodLiteral<true>;
+              role: z.ZodEnum<{
+                admin: "admin";
+                editor: "editor";
+                viewer: "viewer";
+              }>;
+              alreadyExisted: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+              readonly requestId: z.ZodString;
+              readonly surface: z.ZodLiteral<"partner">;
+              readonly version: z.ZodLiteral<"1.0">;
+            }, z.core.$strip>;
+          }, z.core.$strip>>;
+        };
+        readonly errors: readonly ["invalid_request", "unauthorized", "forbidden", "user_not_found", "rate_limited", "internal_error", "contract_violation"];
+        readonly errorResponse: CompatibleResponseSchema<z.ZodObject<{
+          readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+              rate_limited: "rate_limited";
+              internal_error: "internal_error";
+              invalid_request: "invalid_request";
+              unauthorized: "unauthorized";
+              forbidden: "forbidden";
+              user_not_found: "user_not_found";
+              contract_violation: "contract_violation";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+          }, z.core.$strict>;
+        }, z.core.$strip>, z.ZodObject<{
+          readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+              rate_limited: "rate_limited";
+              internal_error: "internal_error";
+              invalid_request: "invalid_request";
+              unauthorized: "unauthorized";
+              forbidden: "forbidden";
+              user_not_found: "user_not_found";
+              contract_violation: "contract_violation";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+          }, z.core.$loose>;
+        }, z.core.$strip>>;
+        readonly resources: {
+          readonly reads: readonly [{
+            readonly type: "partner.team";
+            readonly idFrom: "params.teamId";
+          }];
+          readonly changes: readonly [{
+            readonly type: "partner.team";
+            readonly idFrom: "params.teamId";
+          }];
+        };
+        readonly lifecycle: {
+          readonly introduced: "1.3.0";
+        };
+        readonly docs: {
+          readonly summary: "Add a team member";
+          readonly description: "Adds a user to a team owned by the authenticated partner tenant, or reports it was already a member.";
+          readonly tags: readonly ["Teams"];
+          readonly examples: {
+            readonly request: {
+              readonly params: {
+                readonly teamId: "t_01";
+              };
+              readonly body: {
+                readonly userId: "u_02";
+                readonly role: "editor";
+              };
+            };
+            readonly response: {
+              readonly data: {
+                readonly ok: true;
+                readonly role: "editor";
+              };
+              readonly meta: {
+                readonly requestId: "req_01";
+                readonly surface: "partner";
+                readonly version: "1.0";
+              };
+            };
+          };
+        };
+      };
+      readonly updateTeamMemberRole: {
+        readonly id: "partner.teams.members.role.update";
+        readonly method: "PATCH";
+        readonly path: "/teams/{teamId}/members/{userId}";
+        readonly visibility: "public";
+        readonly semantics: {
+          readonly kind: "mutation";
+          readonly sideEffects: "state";
+          readonly idempotent: true;
+          readonly retry: "idempotent";
+          readonly readConsistency: null;
+        };
+        readonly auth: {
+          readonly credentials: readonly ["partner_key"];
+          readonly scopes: readonly ["teams:write"];
+          readonly ownership: readonly [{
+            readonly credential: "partner_key";
+            readonly rule: "partner_tenant";
+          }];
+        };
+        readonly request: {
+          readonly params: z.ZodObject<{
+            teamId: z.ZodString;
+            userId: z.ZodString;
+          }, z.core.$strict>;
+          readonly query: null;
+          readonly headers: z.ZodObject<{
+            'x-request-id': z.ZodOptional<z.ZodString>;
+          }, z.core.$strict>;
+          readonly body: z.ZodObject<{
+            role: z.ZodEnum<{
+              admin: "admin";
+              editor: "editor";
+              viewer: "viewer";
+            }>;
+          }, z.core.$strict>;
+        };
+        readonly responses: {
+          readonly 200: CompatibleResponseSchema<z.ZodObject<{
+            data: z.ZodObject<{
+              ok: z.ZodLiteral<true>;
+              role: z.ZodEnum<{
+                admin: "admin";
+                editor: "editor";
+                viewer: "viewer";
+              }>;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+              readonly requestId: z.ZodString;
+              readonly surface: z.ZodLiteral<"partner">;
+              readonly version: z.ZodLiteral<"1.0">;
+            }, z.core.$strip>;
+          }, z.core.$strip>, z.ZodObject<{
+            data: z.ZodObject<{
+              ok: z.ZodLiteral<true>;
+              role: z.ZodEnum<{
+                admin: "admin";
+                editor: "editor";
+                viewer: "viewer";
+              }>;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+              readonly requestId: z.ZodString;
+              readonly surface: z.ZodLiteral<"partner">;
+              readonly version: z.ZodLiteral<"1.0">;
+            }, z.core.$strip>;
+          }, z.core.$strip>>;
+        };
+        readonly errors: readonly ["invalid_request", "unauthorized", "forbidden", "user_not_found", "rate_limited", "internal_error", "contract_violation"];
+        readonly errorResponse: CompatibleResponseSchema<z.ZodObject<{
+          readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+              rate_limited: "rate_limited";
+              internal_error: "internal_error";
+              invalid_request: "invalid_request";
+              unauthorized: "unauthorized";
+              forbidden: "forbidden";
+              user_not_found: "user_not_found";
+              contract_violation: "contract_violation";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+          }, z.core.$strict>;
+        }, z.core.$strip>, z.ZodObject<{
+          readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+              rate_limited: "rate_limited";
+              internal_error: "internal_error";
+              invalid_request: "invalid_request";
+              unauthorized: "unauthorized";
+              forbidden: "forbidden";
+              user_not_found: "user_not_found";
+              contract_violation: "contract_violation";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+          }, z.core.$loose>;
+        }, z.core.$strip>>;
+        readonly resources: {
+          readonly reads: readonly [{
+            readonly type: "partner.team";
+            readonly idFrom: "params.teamId";
+          }, {
+            readonly type: "partner.user";
+            readonly idFrom: "params.userId";
+          }];
+          readonly changes: readonly [{
+            readonly type: "partner.team";
+            readonly idFrom: "params.teamId";
+          }, {
+            readonly type: "partner.user";
+            readonly idFrom: "params.userId";
+          }];
+        };
+        readonly lifecycle: {
+          readonly introduced: "1.3.0";
+        };
+        readonly docs: {
+          readonly summary: "Update a team member role";
+          readonly description: "Updates the role of an existing member of a team owned by the authenticated partner tenant.";
+          readonly tags: readonly ["Teams"];
+          readonly examples: {
+            readonly request: {
+              readonly params: {
+                readonly teamId: "t_01";
+                readonly userId: "u_02";
+              };
+              readonly body: {
+                readonly role: "admin";
+              };
+            };
+            readonly response: {
+              readonly data: {
+                readonly ok: true;
+                readonly role: "admin";
+              };
+              readonly meta: {
+                readonly requestId: "req_01";
+                readonly surface: "partner";
+                readonly version: "1.0";
+              };
+            };
+          };
+        };
+      };
+      readonly removeTeamMember: {
+        readonly id: "partner.teams.members.remove";
+        readonly method: "DELETE";
+        readonly path: "/teams/{teamId}/members/{userId}";
+        readonly visibility: "public";
+        readonly semantics: {
+          readonly kind: "mutation";
+          readonly sideEffects: "state";
+          readonly idempotent: true;
+          readonly retry: "idempotent";
+          readonly readConsistency: null;
+        };
+        readonly auth: {
+          readonly credentials: readonly ["partner_key"];
+          readonly scopes: readonly ["teams:write"];
+          readonly ownership: readonly [{
+            readonly credential: "partner_key";
+            readonly rule: "partner_tenant";
+          }];
+        };
+        readonly request: {
+          readonly params: z.ZodObject<{
+            teamId: z.ZodString;
+            userId: z.ZodString;
+          }, z.core.$strict>;
+          readonly query: null;
+          readonly headers: z.ZodObject<{
+            'x-request-id': z.ZodOptional<z.ZodString>;
+          }, z.core.$strict>;
+          readonly body: null;
+        };
+        readonly responses: {
+          readonly 200: CompatibleResponseSchema<z.ZodObject<{
+            data: z.ZodObject<{
+              ok: z.ZodLiteral<true>;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+              readonly requestId: z.ZodString;
+              readonly surface: z.ZodLiteral<"partner">;
+              readonly version: z.ZodLiteral<"1.0">;
+            }, z.core.$strip>;
+          }, z.core.$strip>, z.ZodObject<{
+            data: z.ZodObject<{
+              ok: z.ZodLiteral<true>;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+              readonly requestId: z.ZodString;
+              readonly surface: z.ZodLiteral<"partner">;
+              readonly version: z.ZodLiteral<"1.0">;
+            }, z.core.$strip>;
+          }, z.core.$strip>>;
+        };
+        readonly errors: readonly ["invalid_request", "unauthorized", "forbidden", "user_not_found", "rate_limited", "internal_error", "contract_violation"];
+        readonly errorResponse: CompatibleResponseSchema<z.ZodObject<{
+          readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+              rate_limited: "rate_limited";
+              internal_error: "internal_error";
+              invalid_request: "invalid_request";
+              unauthorized: "unauthorized";
+              forbidden: "forbidden";
+              user_not_found: "user_not_found";
+              contract_violation: "contract_violation";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+          }, z.core.$strict>;
+        }, z.core.$strip>, z.ZodObject<{
+          readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+              rate_limited: "rate_limited";
+              internal_error: "internal_error";
+              invalid_request: "invalid_request";
+              unauthorized: "unauthorized";
+              forbidden: "forbidden";
+              user_not_found: "user_not_found";
+              contract_violation: "contract_violation";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+          }, z.core.$loose>;
+        }, z.core.$strip>>;
+        readonly resources: {
+          readonly reads: readonly [{
+            readonly type: "partner.team";
+            readonly idFrom: "params.teamId";
+          }, {
+            readonly type: "partner.user";
+            readonly idFrom: "params.userId";
+          }];
+          readonly changes: readonly [{
+            readonly type: "partner.team";
+            readonly idFrom: "params.teamId";
+          }, {
+            readonly type: "partner.user";
+            readonly idFrom: "params.userId";
+          }];
+        };
+        readonly lifecycle: {
+          readonly introduced: "1.3.0";
+        };
+        readonly docs: {
+          readonly summary: "Remove a team member";
+          readonly description: "Removes a member from a team owned by the authenticated partner tenant.";
+          readonly tags: readonly ["Teams"];
+          readonly examples: {
+            readonly request: {
+              readonly params: {
+                readonly teamId: "t_01";
+                readonly userId: "u_02";
+              };
+            };
+            readonly response: {
+              readonly data: {
+                readonly ok: true;
+              };
+              readonly meta: {
+                readonly requestId: "req_01";
+                readonly surface: "partner";
+                readonly version: "1.0";
+              };
+            };
+          };
+        };
+      };
+      readonly updateSiteTeam: {
+        readonly id: "partner.sites.team.update";
+        readonly method: "PATCH";
+        readonly path: "/sites/{siteId}/team";
+        readonly visibility: "public";
+        readonly semantics: {
+          readonly kind: "mutation";
+          readonly sideEffects: "state";
+          readonly idempotent: true;
+          readonly retry: "idempotent";
+          readonly readConsistency: null;
+        };
+        readonly auth: {
+          readonly credentials: readonly ["partner_key"];
+          readonly scopes: readonly ["sites:write"];
+          readonly ownership: readonly [{
+            readonly credential: "partner_key";
+            readonly rule: "authorized_site";
+          }];
+        };
+        readonly request: {
+          readonly params: z.ZodObject<{
+            siteId: z.ZodString;
+          }, z.core.$strict>;
+          readonly query: null;
+          readonly headers: z.ZodObject<{
+            'x-request-id': z.ZodOptional<z.ZodString>;
+          }, z.core.$strict>;
+          readonly body: z.ZodObject<{
+            teamId: z.ZodNullable<z.ZodString>;
+          }, z.core.$strict>;
+        };
+        readonly responses: {
+          readonly 200: CompatibleResponseSchema<z.ZodObject<{
+            data: z.ZodObject<{
+              ok: z.ZodLiteral<true>;
+              teamId: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+              readonly requestId: z.ZodString;
+              readonly surface: z.ZodLiteral<"partner">;
+              readonly version: z.ZodLiteral<"1.0">;
+            }, z.core.$strip>;
+          }, z.core.$strip>, z.ZodObject<{
+            data: z.ZodObject<{
+              ok: z.ZodLiteral<true>;
+              teamId: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+              readonly requestId: z.ZodString;
+              readonly surface: z.ZodLiteral<"partner">;
+              readonly version: z.ZodLiteral<"1.0">;
+            }, z.core.$strip>;
+          }, z.core.$strip>>;
+        };
+        readonly errors: readonly ["invalid_request", "unauthorized", "forbidden", "site_not_found", "rate_limited", "internal_error", "contract_violation"];
+        readonly errorResponse: CompatibleResponseSchema<z.ZodObject<{
+          readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+              rate_limited: "rate_limited";
+              internal_error: "internal_error";
+              invalid_request: "invalid_request";
+              unauthorized: "unauthorized";
+              forbidden: "forbidden";
+              site_not_found: "site_not_found";
+              contract_violation: "contract_violation";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+          }, z.core.$strict>;
+        }, z.core.$strip>, z.ZodObject<{
+          readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+              rate_limited: "rate_limited";
+              internal_error: "internal_error";
+              invalid_request: "invalid_request";
+              unauthorized: "unauthorized";
+              forbidden: "forbidden";
+              site_not_found: "site_not_found";
+              contract_violation: "contract_violation";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+          }, z.core.$loose>;
+        }, z.core.$strip>>;
+        readonly resources: {
+          readonly reads: readonly [{
+            readonly type: "site.registration";
+            readonly idFrom: "params.siteId";
+          }];
+          readonly changes: readonly [{
+            readonly type: "site.registration";
+            readonly idFrom: "params.siteId";
+          }];
+        };
+        readonly lifecycle: {
+          readonly introduced: "1.3.0";
+        };
+        readonly docs: {
+          readonly summary: "Bind a site to a team";
+          readonly description: "Binds or unbinds (teamId: null) a partner-owned site to a partner-owned team.";
+          readonly tags: readonly ["Teams"];
+          readonly examples: {
+            readonly request: {
+              readonly params: {
+                readonly siteId: "s_01";
+              };
+              readonly body: {
+                readonly teamId: "t_01";
+              };
+            };
+            readonly response: {
+              readonly data: {
+                readonly ok: true;
+                readonly teamId: "t_01";
+              };
+              readonly meta: {
+                readonly requestId: "req_01";
+                readonly surface: "partner";
+                readonly version: "1.0";
+              };
+            };
+          };
+        };
+      };
+      readonly getTeamCatalog: {
+        readonly id: "partner.teams.catalog.get";
+        readonly method: "GET";
+        readonly path: "/teams/{teamId}/catalog";
+        readonly visibility: "public";
+        readonly semantics: {
+          readonly kind: "query";
+          readonly sideEffects: "none";
+          readonly idempotent: true;
+          readonly retry: "idempotent";
+          readonly readConsistency: "primary";
+        };
+        readonly auth: {
+          readonly credentials: readonly ["partner_key"];
+          readonly scopes: readonly ["teams:read"];
+          readonly ownership: readonly [{
+            readonly credential: "partner_key";
+            readonly rule: "partner_tenant";
+          }];
+        };
+        readonly request: {
+          readonly params: z.ZodObject<{
+            teamId: z.ZodString;
+          }, z.core.$strict>;
+          readonly query: null;
+          readonly headers: z.ZodObject<{
+            'x-request-id': z.ZodOptional<z.ZodString>;
+          }, z.core.$strict>;
+          readonly body: null;
+        };
+        readonly responses: {
+          readonly 200: CompatibleResponseSchema<z.ZodObject<{
+            data: z.ZodObject<{
+              teamId: z.ZodString;
+              catalogUri: z.ZodNullable<z.ZodString>;
+              warehouse: z.ZodNullable<z.ZodString>;
+              bucket: z.ZodNullable<z.ZodString>;
+              namespace: z.ZodNullable<z.ZodString>;
+              provisioningState: z.ZodNullable<z.ZodString>;
+              keyEncoding: z.ZodNullable<z.ZodString>;
+              catalogTablesReady: z.ZodBoolean;
+              readsEnabled: z.ZodBoolean;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+              readonly requestId: z.ZodString;
+              readonly surface: z.ZodLiteral<"partner">;
+              readonly version: z.ZodLiteral<"1.0">;
+            }, z.core.$strip>;
+          }, z.core.$strip>, z.ZodObject<{
+            data: z.ZodObject<{
+              teamId: z.ZodString;
+              catalogUri: z.ZodNullable<z.ZodString>;
+              warehouse: z.ZodNullable<z.ZodString>;
+              bucket: z.ZodNullable<z.ZodString>;
+              namespace: z.ZodNullable<z.ZodString>;
+              provisioningState: z.ZodNullable<z.ZodString>;
+              keyEncoding: z.ZodNullable<z.ZodString>;
+              catalogTablesReady: z.ZodBoolean;
+              readsEnabled: z.ZodBoolean;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+              readonly requestId: z.ZodString;
+              readonly surface: z.ZodLiteral<"partner">;
+              readonly version: z.ZodLiteral<"1.0">;
+            }, z.core.$strip>;
+          }, z.core.$strip>>;
+        };
+        readonly errors: readonly ["invalid_request", "unauthorized", "forbidden", "user_not_found", "rate_limited", "internal_error", "contract_violation"];
+        readonly errorResponse: CompatibleResponseSchema<z.ZodObject<{
+          readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+              rate_limited: "rate_limited";
+              internal_error: "internal_error";
+              invalid_request: "invalid_request";
+              unauthorized: "unauthorized";
+              forbidden: "forbidden";
+              user_not_found: "user_not_found";
+              contract_violation: "contract_violation";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+          }, z.core.$strict>;
+        }, z.core.$strip>, z.ZodObject<{
+          readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+              rate_limited: "rate_limited";
+              internal_error: "internal_error";
+              invalid_request: "invalid_request";
+              unauthorized: "unauthorized";
+              forbidden: "forbidden";
+              user_not_found: "user_not_found";
+              contract_violation: "contract_violation";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+          }, z.core.$loose>;
+        }, z.core.$strip>>;
+        readonly resources: {
+          readonly reads: readonly [{
+            readonly type: "partner.team";
+            readonly idFrom: "params.teamId";
+          }];
+          readonly changes: readonly [];
+        };
+        readonly lifecycle: {
+          readonly introduced: "1.3.0";
+        };
+        readonly docs: {
+          readonly summary: "Get a team catalog";
+          readonly description: "Returns the Iceberg catalog reference bound to a partner-owned team, if any.";
+          readonly tags: readonly ["Teams"];
+          readonly examples: {
+            readonly request: {
+              readonly params: {
+                readonly teamId: "t_01";
+              };
+            };
+            readonly response: {
+              readonly data: {
+                readonly teamId: "t_01";
+                readonly catalogUri: null;
+                readonly warehouse: null;
+                readonly bucket: null;
+                readonly namespace: null;
+                readonly provisioningState: null;
+                readonly keyEncoding: null;
+                readonly catalogTablesReady: false;
+                readonly readsEnabled: false;
+              };
+              readonly meta: {
+                readonly requestId: "req_01";
+                readonly surface: "partner";
+                readonly version: "1.0";
+              };
+            };
+          };
+        };
+      };
+      readonly bindTeamCatalog: {
+        readonly id: "partner.teams.catalog.bind";
+        readonly method: "POST";
+        readonly path: "/teams/{teamId}/catalog";
+        readonly visibility: "public";
+        readonly semantics: {
+          readonly kind: "mutation";
+          readonly sideEffects: "state";
+          readonly idempotent: true;
+          readonly retry: "idempotent";
+          readonly readConsistency: null;
+        };
+        readonly auth: {
+          readonly credentials: readonly ["partner_key"];
+          readonly scopes: readonly ["teams:write"];
+          readonly ownership: readonly [{
+            readonly credential: "partner_key";
+            readonly rule: "partner_tenant";
+          }];
+        };
+        readonly request: {
+          readonly params: z.ZodObject<{
+            teamId: z.ZodString;
+          }, z.core.$strict>;
+          readonly query: null;
+          readonly headers: z.ZodObject<{
+            'x-request-id': z.ZodOptional<z.ZodString>;
+          }, z.core.$strict>;
+          readonly body: z.ZodObject<{
+            catalogUri: z.ZodString;
+            warehouse: z.ZodString;
+            namespace: z.ZodOptional<z.ZodString>;
+            bucket: z.ZodOptional<z.ZodString>;
+          }, z.core.$strict>;
+        };
+        readonly responses: {
+          readonly 200: CompatibleResponseSchema<z.ZodObject<{
+            data: z.ZodObject<{
+              teamId: z.ZodString;
+              status: z.ZodLiteral<"ready">;
+              catalogUri: z.ZodString;
+              warehouse: z.ZodString;
+              bucket: z.ZodString;
+              namespace: z.ZodString;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+              readonly requestId: z.ZodString;
+              readonly surface: z.ZodLiteral<"partner">;
+              readonly version: z.ZodLiteral<"1.0">;
+            }, z.core.$strip>;
+          }, z.core.$strip>, z.ZodObject<{
+            data: z.ZodObject<{
+              teamId: z.ZodString;
+              status: z.ZodLiteral<"ready">;
+              catalogUri: z.ZodString;
+              warehouse: z.ZodString;
+              bucket: z.ZodString;
+              namespace: z.ZodString;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+              readonly requestId: z.ZodString;
+              readonly surface: z.ZodLiteral<"partner">;
+              readonly version: z.ZodLiteral<"1.0">;
+            }, z.core.$strip>;
+          }, z.core.$strip>>;
+        };
+        readonly errors: readonly ["invalid_request", "unauthorized", "forbidden", "user_not_found", "rate_limited", "internal_error", "contract_violation"];
+        readonly errorResponse: CompatibleResponseSchema<z.ZodObject<{
+          readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+              rate_limited: "rate_limited";
+              internal_error: "internal_error";
+              invalid_request: "invalid_request";
+              unauthorized: "unauthorized";
+              forbidden: "forbidden";
+              user_not_found: "user_not_found";
+              contract_violation: "contract_violation";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+          }, z.core.$strict>;
+        }, z.core.$strip>, z.ZodObject<{
+          readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+              rate_limited: "rate_limited";
+              internal_error: "internal_error";
+              invalid_request: "invalid_request";
+              unauthorized: "unauthorized";
+              forbidden: "forbidden";
+              user_not_found: "user_not_found";
+              contract_violation: "contract_violation";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+          }, z.core.$loose>;
+        }, z.core.$strip>>;
+        readonly resources: {
+          readonly reads: readonly [{
+            readonly type: "partner.team";
+            readonly idFrom: "params.teamId";
+          }];
+          readonly changes: readonly [{
+            readonly type: "partner.team";
+            readonly idFrom: "params.teamId";
+          }];
+        };
+        readonly lifecycle: {
+          readonly introduced: "1.3.0";
+        };
+        readonly docs: {
+          readonly summary: "Bind a team catalog";
+          readonly description: "Binds an Iceberg catalog (URI, warehouse, and optional bucket/namespace) to a partner-owned team.";
+          readonly tags: readonly ["Teams"];
+          readonly examples: {
+            readonly request: {
+              readonly params: {
+                readonly teamId: "t_01";
+              };
+              readonly body: {
+                readonly catalogUri: "gs://bucket/catalog";
+                readonly warehouse: "primary";
+                readonly namespace: "ns1";
+                readonly bucket: "bucket1";
+              };
+            };
+            readonly response: {
+              readonly data: {
+                readonly teamId: "t_01";
+                readonly status: "ready";
+                readonly catalogUri: "gs://bucket/catalog";
+                readonly warehouse: "primary";
+                readonly bucket: "bucket1";
+                readonly namespace: "ns1";
+              };
+              readonly meta: {
+                readonly requestId: "req_01";
+                readonly surface: "partner";
+                readonly version: "1.0";
+              };
+            };
+          };
+        };
+      };
+      readonly getSiteIntIdCrosswalk: {
+        readonly id: "partner.users.sites.crosswalk.get";
+        readonly method: "GET";
+        readonly path: "/users/{userId}/sites/crosswalk";
+        readonly visibility: "public";
+        readonly semantics: {
+          readonly kind: "query";
+          readonly sideEffects: "none";
+          readonly idempotent: true;
+          readonly retry: "idempotent";
+          readonly readConsistency: "primary";
+        };
+        readonly auth: {
+          readonly credentials: readonly ["user_key", "partner_key"];
+          readonly scopes: readonly ["sites:read"];
+          readonly ownership: readonly [{
+            readonly credential: "user_key";
+            readonly rule: "self";
+          }, {
+            readonly credential: "partner_key";
+            readonly rule: "linked_user";
+          }];
+        };
+        readonly request: {
+          readonly params: z.ZodObject<{
+            userId: z.ZodString;
+          }, z.core.$strict>;
+          readonly query: null;
+          readonly headers: z.ZodObject<{
+            'x-request-id': z.ZodOptional<z.ZodString>;
+          }, z.core.$strict>;
+          readonly body: null;
+        };
+        readonly responses: {
+          readonly 200: CompatibleResponseSchema<z.ZodObject<{
+            data: z.ZodObject<{
+              crosswalk: z.ZodRecord<z.ZodString, z.ZodNumber>;
+              sites: z.ZodArray<z.ZodObject<{
+                siteId: z.ZodString;
+                intId: z.ZodNumber;
+                siteUrl: z.ZodString;
+              }, z.core.$loose>>;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+              readonly requestId: z.ZodString;
+              readonly surface: z.ZodLiteral<"partner">;
+              readonly version: z.ZodLiteral<"1.0">;
+            }, z.core.$strip>;
+          }, z.core.$strip>, z.ZodObject<{
+            data: z.ZodObject<{
+              crosswalk: z.ZodRecord<z.ZodString, z.ZodNumber>;
+              sites: z.ZodArray<z.ZodObject<{
+                siteId: z.ZodString;
+                intId: z.ZodNumber;
+                siteUrl: z.ZodString;
+              }, z.core.$loose>>;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+              readonly requestId: z.ZodString;
+              readonly surface: z.ZodLiteral<"partner">;
+              readonly version: z.ZodLiteral<"1.0">;
+            }, z.core.$strip>;
+          }, z.core.$strip>>;
+        };
+        readonly errors: readonly ["invalid_request", "unauthorized", "forbidden", "user_not_found", "rate_limited", "internal_error", "contract_violation"];
+        readonly errorResponse: CompatibleResponseSchema<z.ZodObject<{
+          readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+              rate_limited: "rate_limited";
+              internal_error: "internal_error";
+              invalid_request: "invalid_request";
+              unauthorized: "unauthorized";
+              forbidden: "forbidden";
+              user_not_found: "user_not_found";
+              contract_violation: "contract_violation";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+          }, z.core.$strict>;
+        }, z.core.$strip>, z.ZodObject<{
+          readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+              rate_limited: "rate_limited";
+              internal_error: "internal_error";
+              invalid_request: "invalid_request";
+              unauthorized: "unauthorized";
+              forbidden: "forbidden";
+              user_not_found: "user_not_found";
+              contract_violation: "contract_violation";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+          }, z.core.$loose>;
+        }, z.core.$strip>>;
+        readonly resources: {
+          readonly reads: readonly [{
+            readonly type: "partner.user";
+            readonly idFrom: "params.userId";
+          }, {
+            readonly type: "user.sites";
+            readonly idFrom: "params.userId";
+          }];
+          readonly changes: readonly [];
+        };
+        readonly lifecycle: {
+          readonly introduced: "1.3.0";
+        };
+        readonly docs: {
+          readonly summary: "Get the site int-id crosswalk";
+          readonly description: "Maps a user's public site IDs to their internal integer IDs, for partners that need the legacy numeric identifier.";
+          readonly tags: readonly ["Sites"];
+          readonly examples: {
+            readonly request: {
+              readonly params: {
+                readonly userId: "u_01";
+              };
+            };
+            readonly response: {
+              readonly data: {
+                readonly crosswalk: {};
+                readonly sites: readonly [];
+              };
+              readonly meta: {
+                readonly requestId: "req_01";
+                readonly surface: "partner";
+                readonly version: "1.0";
+              };
+            };
+          };
+        };
+      };
+      readonly deleteUser: {
+        readonly id: "partner.users.delete";
+        readonly method: "DELETE";
+        readonly path: "/users/{userId}";
+        readonly visibility: "public";
+        readonly semantics: {
+          readonly kind: "mutation";
+          readonly sideEffects: "state";
+          readonly idempotent: true;
+          readonly retry: "idempotent";
+          readonly readConsistency: null;
+        };
+        readonly auth: {
+          readonly credentials: readonly ["partner_key"];
+          readonly scopes: readonly ["users:write"];
+          readonly ownership: readonly [{
+            readonly credential: "partner_key";
+            readonly rule: "linked_user";
+          }];
+        };
+        readonly request: {
+          readonly params: z.ZodObject<{
+            userId: z.ZodString;
+          }, z.core.$strict>;
+          readonly query: null;
+          readonly headers: z.ZodObject<{
+            'x-request-id': z.ZodOptional<z.ZodString>;
+          }, z.core.$strict>;
+          readonly body: null;
+        };
+        readonly responses: {
+          readonly 200: CompatibleResponseSchema<z.ZodObject<{
+            data: z.ZodObject<{
+              ok: z.ZodLiteral<true>;
+              queued: z.ZodLiteral<true>;
+              userId: z.ZodNumber;
+              publicId: z.ZodString;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+              readonly requestId: z.ZodString;
+              readonly surface: z.ZodLiteral<"partner">;
+              readonly version: z.ZodLiteral<"1.0">;
+            }, z.core.$strip>;
+          }, z.core.$strip>, z.ZodObject<{
+            data: z.ZodObject<{
+              ok: z.ZodLiteral<true>;
+              queued: z.ZodLiteral<true>;
+              userId: z.ZodNumber;
+              publicId: z.ZodString;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+              readonly requestId: z.ZodString;
+              readonly surface: z.ZodLiteral<"partner">;
+              readonly version: z.ZodLiteral<"1.0">;
+            }, z.core.$strip>;
+          }, z.core.$strip>>;
+        };
+        readonly errors: readonly ["invalid_request", "unauthorized", "forbidden", "user_not_found", "rate_limited", "internal_error", "contract_violation"];
+        readonly errorResponse: CompatibleResponseSchema<z.ZodObject<{
+          readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+              rate_limited: "rate_limited";
+              internal_error: "internal_error";
+              invalid_request: "invalid_request";
+              unauthorized: "unauthorized";
+              forbidden: "forbidden";
+              user_not_found: "user_not_found";
+              contract_violation: "contract_violation";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+          }, z.core.$strict>;
+        }, z.core.$strip>, z.ZodObject<{
+          readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+              rate_limited: "rate_limited";
+              internal_error: "internal_error";
+              invalid_request: "invalid_request";
+              unauthorized: "unauthorized";
+              forbidden: "forbidden";
+              user_not_found: "user_not_found";
+              contract_violation: "contract_violation";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+          }, z.core.$loose>;
+        }, z.core.$strip>>;
+        readonly resources: {
+          readonly reads: readonly [{
+            readonly type: "partner.user";
+            readonly idFrom: "params.userId";
+          }];
+          readonly changes: readonly [{
+            readonly type: "partner.user";
+            readonly idFrom: "params.userId";
+          }, {
+            readonly type: "user.sites";
+            readonly idFrom: "params.userId";
+          }];
+        };
+        readonly lifecycle: {
+          readonly introduced: "1.3.0";
+        };
+        readonly docs: {
+          readonly summary: "Delete a partner user";
+          readonly description: "Queues cascade deletion of a partner-linked user and their sites.";
+          readonly tags: readonly ["Users"];
+          readonly examples: {
+            readonly request: {
+              readonly params: {
+                readonly userId: "u_01";
+              };
+            };
+            readonly response: {
+              readonly data: {
+                readonly ok: true;
+                readonly queued: true;
+                readonly userId: 1;
+                readonly publicId: "u_01";
+              };
+              readonly meta: {
+                readonly requestId: "req_01";
+                readonly surface: "partner";
+                readonly version: "1.0";
+              };
+            };
+          };
+        };
+      };
+      readonly createVerificationToken: {
+        readonly id: "partner.users.verification.token.create";
+        readonly method: "POST";
+        readonly path: "/users/{userId}/verification-token";
+        readonly visibility: "public";
+        readonly semantics: {
+          readonly kind: "query";
+          readonly sideEffects: "none";
+          readonly idempotent: true;
+          readonly retry: "idempotent";
+          readonly readConsistency: "primary";
+        };
+        readonly auth: {
+          readonly credentials: readonly ["user_key", "partner_key"];
+          readonly scopes: readonly ["sites:write"];
+          readonly ownership: readonly [{
+            readonly credential: "user_key";
+            readonly rule: "self";
+          }, {
+            readonly credential: "partner_key";
+            readonly rule: "linked_user";
+          }];
+        };
+        readonly request: {
+          readonly params: z.ZodObject<{
+            userId: z.ZodString;
+          }, z.core.$strict>;
+          readonly query: null;
+          readonly headers: z.ZodObject<{
+            'x-request-id': z.ZodOptional<z.ZodString>;
+          }, z.core.$strict>;
+          readonly body: z.ZodObject<{
+            siteUrl: z.ZodString;
+            method: z.ZodOptional<z.ZodEnum<{
+              META: "META";
+              FILE: "FILE";
+              DNS_TXT: "DNS_TXT";
+              DNS_CNAME: "DNS_CNAME";
+              ANALYTICS: "ANALYTICS";
+              TAG_MANAGER: "TAG_MANAGER";
+            }>>;
+          }, z.core.$strict>;
+        };
+        readonly responses: {
+          readonly 200: CompatibleResponseSchema<z.ZodObject<{
+            data: z.ZodObject<{
+              readonly siteUrl: z.ZodString;
+              readonly site: z.ZodObject<{
+                type: z.ZodString;
+                identifier: z.ZodString;
+              }, z.core.$loose>;
+              readonly method: z.ZodString;
+              readonly token: z.ZodString;
+              readonly metaContent: z.ZodNullable<z.ZodString>;
+              readonly dnsRecord: z.ZodNullable<z.ZodObject<{
+                type: z.ZodEnum<{
+                  TXT: "TXT";
+                  CNAME: "CNAME";
+                }>;
+                host: z.ZodString;
+                value: z.ZodString;
+              }, z.core.$strip>>;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+              readonly requestId: z.ZodString;
+              readonly surface: z.ZodLiteral<"partner">;
+              readonly version: z.ZodLiteral<"1.0">;
+            }, z.core.$strip>;
+          }, z.core.$strip>, z.ZodObject<{
+            data: z.ZodObject<{
+              readonly siteUrl: z.ZodString;
+              readonly site: z.ZodObject<{
+                type: z.ZodString;
+                identifier: z.ZodString;
+              }, z.core.$loose>;
+              readonly method: z.ZodString;
+              readonly token: z.ZodString;
+              readonly metaContent: z.ZodNullable<z.ZodString>;
+              readonly dnsRecord: z.ZodNullable<z.ZodObject<{
+                type: z.ZodEnum<{
+                  TXT: "TXT";
+                  CNAME: "CNAME";
+                }>;
+                host: z.ZodString;
+                value: z.ZodString;
+              }, z.core.$strip>>;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+              readonly requestId: z.ZodString;
+              readonly surface: z.ZodLiteral<"partner">;
+              readonly version: z.ZodLiteral<"1.0">;
+            }, z.core.$strip>;
+          }, z.core.$strip>>;
+        };
+        readonly errors: readonly ["invalid_request", "unauthorized", "forbidden", "user_not_found", "rate_limited", "internal_error", "contract_violation"];
+        readonly errorResponse: CompatibleResponseSchema<z.ZodObject<{
+          readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+              rate_limited: "rate_limited";
+              internal_error: "internal_error";
+              invalid_request: "invalid_request";
+              unauthorized: "unauthorized";
+              forbidden: "forbidden";
+              user_not_found: "user_not_found";
+              contract_violation: "contract_violation";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+          }, z.core.$strict>;
+        }, z.core.$strip>, z.ZodObject<{
+          readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+              rate_limited: "rate_limited";
+              internal_error: "internal_error";
+              invalid_request: "invalid_request";
+              unauthorized: "unauthorized";
+              forbidden: "forbidden";
+              user_not_found: "user_not_found";
+              contract_violation: "contract_violation";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+          }, z.core.$loose>;
+        }, z.core.$strip>>;
+        readonly resources: {
+          readonly reads: readonly [{
+            readonly type: "partner.user";
+            readonly idFrom: "params.userId";
+          }, {
+            readonly type: "user.sites";
+            readonly idFrom: "params.userId";
+          }];
+          readonly changes: readonly [];
+        };
+        readonly lifecycle: {
+          readonly introduced: "1.3.0";
+        };
+        readonly docs: {
+          readonly summary: "Create a site verification token";
+          readonly description: "Mints a Search Console site-ownership verification token (meta tag or DNS record) for a not-yet-registered site.";
+          readonly tags: readonly ["Sites"];
+          readonly examples: {
+            readonly request: {
+              readonly params: {
+                readonly userId: "u_01";
+              };
+              readonly body: {
+                readonly siteUrl: "https://example.com";
+                readonly method: "DNS_TXT";
+              };
+            };
+            readonly response: {
+              readonly data: {
+                readonly siteUrl: "https://example.com";
+                readonly site: {
+                  readonly type: "INET_DOMAIN";
+                  readonly identifier: "example.com";
+                };
+                readonly method: "DNS_TXT";
+                readonly token: "abc123";
+                readonly metaContent: null;
+                readonly dnsRecord: {
+                  readonly type: "TXT";
+                  readonly host: "_gsc.example.com";
+                  readonly value: "abc123";
+                };
+              };
+              readonly meta: {
+                readonly requestId: "req_01";
+                readonly surface: "partner";
+                readonly version: "1.0";
+              };
+            };
+          };
+        };
+      };
+      readonly addAndVerifySite: {
+        readonly id: "partner.users.sites.verify.create";
+        readonly method: "POST";
+        readonly path: "/users/{userId}/sites/verify";
+        readonly visibility: "public";
+        readonly semantics: {
+          readonly kind: "mutation";
+          readonly sideEffects: "state";
+          readonly idempotent: true;
+          readonly retry: "idempotent";
+          readonly readConsistency: null;
+        };
+        readonly auth: {
+          readonly credentials: readonly ["user_key", "partner_key"];
+          readonly scopes: readonly ["sites:write"];
+          readonly ownership: readonly [{
+            readonly credential: "user_key";
+            readonly rule: "self";
+          }, {
+            readonly credential: "partner_key";
+            readonly rule: "linked_user";
+          }];
+        };
+        readonly request: {
+          readonly params: z.ZodObject<{
+            userId: z.ZodString;
+          }, z.core.$strict>;
+          readonly query: null;
+          readonly headers: z.ZodObject<{
+            'x-request-id': z.ZodOptional<z.ZodString>;
+          }, z.core.$strict>;
+          readonly body: z.ZodObject<{
+            siteUrl: z.ZodString;
+            method: z.ZodOptional<z.ZodEnum<{
+              META: "META";
+              FILE: "FILE";
+              DNS_TXT: "DNS_TXT";
+              DNS_CNAME: "DNS_CNAME";
+              ANALYTICS: "ANALYTICS";
+              TAG_MANAGER: "TAG_MANAGER";
+            }>>;
+          }, z.core.$strict>;
+        };
+        readonly responses: {
+          readonly 200: CompatibleResponseSchema<z.ZodObject<{
+            data: z.ZodObject<{
+              readonly siteUrl: z.ZodString;
+              readonly site: z.ZodObject<{
+                type: z.ZodString;
+                identifier: z.ZodString;
+              }, z.core.$loose>;
+              readonly method: z.ZodString;
+              readonly verified: z.ZodLiteral<true>;
+              readonly owners: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+              readonly requestId: z.ZodString;
+              readonly surface: z.ZodLiteral<"partner">;
+              readonly version: z.ZodLiteral<"1.0">;
+            }, z.core.$strip>;
+          }, z.core.$strip>, z.ZodObject<{
+            data: z.ZodObject<{
+              readonly siteUrl: z.ZodString;
+              readonly site: z.ZodObject<{
+                type: z.ZodString;
+                identifier: z.ZodString;
+              }, z.core.$loose>;
+              readonly method: z.ZodString;
+              readonly verified: z.ZodLiteral<true>;
+              readonly owners: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+              readonly requestId: z.ZodString;
+              readonly surface: z.ZodLiteral<"partner">;
+              readonly version: z.ZodLiteral<"1.0">;
+            }, z.core.$strip>;
+          }, z.core.$strip>>;
+        };
+        readonly errors: readonly ["invalid_request", "unauthorized", "forbidden", "user_not_found", "rate_limited", "internal_error", "contract_violation"];
+        readonly errorResponse: CompatibleResponseSchema<z.ZodObject<{
+          readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+              rate_limited: "rate_limited";
+              internal_error: "internal_error";
+              invalid_request: "invalid_request";
+              unauthorized: "unauthorized";
+              forbidden: "forbidden";
+              user_not_found: "user_not_found";
+              contract_violation: "contract_violation";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+          }, z.core.$strict>;
+        }, z.core.$strip>, z.ZodObject<{
+          readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+              rate_limited: "rate_limited";
+              internal_error: "internal_error";
+              invalid_request: "invalid_request";
+              unauthorized: "unauthorized";
+              forbidden: "forbidden";
+              user_not_found: "user_not_found";
+              contract_violation: "contract_violation";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+          }, z.core.$loose>;
+        }, z.core.$strip>>;
+        readonly resources: {
+          readonly reads: readonly [{
+            readonly type: "partner.user";
+            readonly idFrom: "params.userId";
+          }];
+          readonly changes: readonly [{
+            readonly type: "user.sites";
+            readonly idFrom: "params.userId";
+          }];
+        };
+        readonly lifecycle: {
+          readonly introduced: "1.3.0";
+        };
+        readonly docs: {
+          readonly summary: "Add and verify a site";
+          readonly description: "Verifies Search Console ownership of a site for a user via the given method and records the verified ownership.";
+          readonly tags: readonly ["Sites"];
+          readonly examples: {
+            readonly request: {
+              readonly params: {
+                readonly userId: "u_01";
+              };
+              readonly body: {
+                readonly siteUrl: "https://example.com";
+                readonly method: "DNS_TXT";
+              };
+            };
+            readonly response: {
+              readonly data: {
+                readonly siteUrl: "https://example.com";
+                readonly site: {
+                  readonly type: "INET_DOMAIN";
+                  readonly identifier: "example.com";
+                };
+                readonly method: "DNS_TXT";
+                readonly verified: true;
+                readonly owners: readonly ["owner@example.com"];
+              };
+              readonly meta: {
+                readonly requestId: "req_01";
+                readonly surface: "partner";
+                readonly version: "1.0";
+              };
+            };
+          };
+        };
+      };
+      readonly queryCrossSource: {
+        readonly id: "partner.sites.cross.source.query";
+        readonly method: "POST";
+        readonly path: "/sites/{siteId}/cross-source";
+        readonly visibility: "public";
+        readonly semantics: {
+          readonly kind: "query";
+          readonly sideEffects: "none";
+          readonly idempotent: true;
+          readonly retry: "idempotent";
+          readonly readConsistency: "primary";
+        };
+        readonly auth: {
+          readonly credentials: readonly ["partner_key"];
+          readonly scopes: readonly ["analytics:read"];
+          readonly ownership: readonly [{
+            readonly credential: "partner_key";
+            readonly rule: "authorized_site";
+          }];
+        };
+        readonly request: {
+          readonly params: z.ZodObject<{
+            siteId: z.ZodString;
+          }, z.core.$strict>;
+          readonly query: null;
+          readonly headers: z.ZodObject<{
+            'x-request-id': z.ZodOptional<z.ZodString>;
+          }, z.core.$strict>;
+          readonly body: z.ZodObject<{
+            queryKey: z.ZodEnum<{
+              "crawl-error-losing-impressions": "crawl-error-losing-impressions";
+              "declining-clicks-poor-lcp": "declining-clicks-poor-lcp";
+              "striking-distance-slow-pages": "striking-distance-slow-pages";
+              "top-impressions-low-performance": "top-impressions-low-performance";
+            }>;
+            rangeDays: z.ZodOptional<z.ZodNumber>;
+            limit: z.ZodOptional<z.ZodNumber>;
+          }, z.core.$strict>;
+        };
+        readonly responses: {
+          readonly 200: CompatibleResponseSchema<z.ZodObject<{
+            data: z.ZodObject<{
+              readonly reason: z.ZodOptional<z.ZodString>;
+              readonly sources: z.ZodArray<z.ZodString>;
+              readonly rows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+              readonly requestId: z.ZodString;
+              readonly surface: z.ZodLiteral<"partner">;
+              readonly version: z.ZodLiteral<"1.0">;
+            }, z.core.$strip>;
+          }, z.core.$strip>, z.ZodObject<{
+            data: z.ZodObject<{
+              readonly reason: z.ZodOptional<z.ZodString>;
+              readonly sources: z.ZodArray<z.ZodString>;
+              readonly rows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+              readonly requestId: z.ZodString;
+              readonly surface: z.ZodLiteral<"partner">;
+              readonly version: z.ZodLiteral<"1.0">;
+            }, z.core.$strip>;
+          }, z.core.$strip>>;
+        };
+        readonly errors: readonly ["invalid_request", "unauthorized", "forbidden", "site_not_found", "rate_limited", "internal_error", "contract_violation"];
+        readonly errorResponse: CompatibleResponseSchema<z.ZodObject<{
+          readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+              rate_limited: "rate_limited";
+              internal_error: "internal_error";
+              invalid_request: "invalid_request";
+              unauthorized: "unauthorized";
+              forbidden: "forbidden";
+              site_not_found: "site_not_found";
+              contract_violation: "contract_violation";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+          }, z.core.$strict>;
+        }, z.core.$strip>, z.ZodObject<{
+          readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+              rate_limited: "rate_limited";
+              internal_error: "internal_error";
+              invalid_request: "invalid_request";
+              unauthorized: "unauthorized";
+              forbidden: "forbidden";
+              site_not_found: "site_not_found";
+              contract_violation: "contract_violation";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+          }, z.core.$loose>;
+        }, z.core.$strip>>;
+        readonly resources: {
+          readonly reads: readonly [{
+            readonly type: "site.analytics";
+            readonly idFrom: "params.siteId";
+          }];
+          readonly changes: readonly [];
+        };
+        readonly lifecycle: {
+          readonly introduced: "1.3.0";
+        };
+        readonly docs: {
+          readonly summary: "Query cross-source analysis";
+          readonly description: "Runs one predefined cross-source query joining crawl, CWV, and GSC signals for a site.";
+          readonly tags: readonly ["Analytics"];
+          readonly examples: {
+            readonly request: {
+              readonly params: {
+                readonly siteId: "s_01";
+              };
+              readonly body: {
+                readonly queryKey: "crawl-error-losing-impressions";
+                readonly rangeDays: 28;
+                readonly limit: 50;
+              };
+            };
+            readonly response: {
+              readonly data: {
+                readonly sources: readonly ["crawl", "gsc"];
+                readonly rows: readonly [];
+              };
+              readonly meta: {
+                readonly requestId: "req_01";
+                readonly surface: "partner";
+                readonly version: "1.0";
+              };
+            };
+          };
+        };
+      };
+      readonly enrichKeywords: {
+        readonly id: "partner.keywords.enrich.query";
+        readonly method: "POST";
+        readonly path: "/keywords/enrich";
+        readonly visibility: "public";
+        readonly semantics: {
+          readonly kind: "query";
+          readonly sideEffects: "none";
+          readonly idempotent: true;
+          readonly retry: "idempotent";
+          readonly readConsistency: "primary";
+        };
+        readonly auth: {
+          readonly credentials: readonly ["user_key", "partner_key"];
+          readonly scopes: readonly ["analytics:read"];
+          readonly ownership: readonly [{
+            readonly credential: "user_key";
+            readonly rule: "self";
+          }, {
+            readonly credential: "partner_key";
+            readonly rule: "partner_tenant";
+          }];
+        };
+        readonly request: {
+          readonly params: null;
+          readonly query: null;
+          readonly headers: z.ZodObject<{
+            'x-request-id': z.ZodOptional<z.ZodString>;
+          }, z.core.$strict>;
+          readonly body: z.ZodObject<{
+            keywords: z.ZodArray<z.ZodString>;
+          }, z.core.$strict>;
+        };
+        readonly responses: {
+          readonly 200: CompatibleResponseSchema<z.ZodObject<{
+            data: z.ZodObject<{
+              readonly metrics: z.ZodRecord<z.ZodString, z.ZodObject<{
+                difficulty: z.ZodNullable<z.ZodNumber>;
+                searchVolume: z.ZodNullable<z.ZodNumber>;
+                cpc: z.ZodNullable<z.ZodNumber>;
+              }, z.core.$loose>>;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+              readonly requestId: z.ZodString;
+              readonly surface: z.ZodLiteral<"partner">;
+              readonly version: z.ZodLiteral<"1.0">;
+            }, z.core.$strip>;
+          }, z.core.$strip>, z.ZodObject<{
+            data: z.ZodObject<{
+              readonly metrics: z.ZodRecord<z.ZodString, z.ZodObject<{
+                difficulty: z.ZodNullable<z.ZodNumber>;
+                searchVolume: z.ZodNullable<z.ZodNumber>;
+                cpc: z.ZodNullable<z.ZodNumber>;
+              }, z.core.$loose>>;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+              readonly requestId: z.ZodString;
+              readonly surface: z.ZodLiteral<"partner">;
+              readonly version: z.ZodLiteral<"1.0">;
+            }, z.core.$strip>;
+          }, z.core.$strip>>;
+        };
+        readonly errors: readonly ["invalid_request", "unauthorized", "forbidden", "user_not_found", "rate_limited", "internal_error", "contract_violation"];
+        readonly errorResponse: CompatibleResponseSchema<z.ZodObject<{
+          readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+              rate_limited: "rate_limited";
+              internal_error: "internal_error";
+              invalid_request: "invalid_request";
+              unauthorized: "unauthorized";
+              forbidden: "forbidden";
+              user_not_found: "user_not_found";
+              contract_violation: "contract_violation";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+          }, z.core.$strict>;
+        }, z.core.$strip>, z.ZodObject<{
+          readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+              rate_limited: "rate_limited";
+              internal_error: "internal_error";
+              invalid_request: "invalid_request";
+              unauthorized: "unauthorized";
+              forbidden: "forbidden";
+              user_not_found: "user_not_found";
+              contract_violation: "contract_violation";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+          }, z.core.$loose>;
+        }, z.core.$strip>>;
+        readonly resources: {
+          readonly reads: readonly [];
+          readonly changes: readonly [];
+        };
+        readonly lifecycle: {
+          readonly introduced: "1.3.0";
+        };
+        readonly docs: {
+          readonly summary: "Enrich keywords with metrics";
+          readonly description: "Returns difficulty, search volume, and CPC estimates for up to 500 keywords.";
+          readonly tags: readonly ["Analytics"];
+          readonly examples: {
+            readonly request: {
+              readonly body: {
+                readonly keywords: readonly ["nuxt seo"];
+              };
+            };
+            readonly response: {
+              readonly data: {
+                readonly metrics: {
+                  readonly 'nuxt seo': {
+                    readonly difficulty: 40;
+                    readonly searchVolume: 100;
+                    readonly cpc: 1.2;
+                  };
+                };
+              };
+              readonly meta: {
+                readonly requestId: "req_01";
+                readonly surface: "partner";
+                readonly version: "1.0";
+              };
+            };
+          };
+        };
+      };
     }>;
     analytics: HttpV1Surface<{
       readonly queryRows: {