@nuxtseo/protocol 0.1.5 → 0.2.0

package/dist/v1/gsc.d.ts

@@ -3834,6 +3834,528 @@ export declare const urlInspectionReadOperation: {
         }];
     };
 };
+export declare const indexCohortsQuerySchema: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    minSectionPages: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;
+export declare const establishedCohortSchema: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
+    readonly family: z.ZodString;
+    readonly dimension: z.ZodString;
+    /**
+     * Null when the cohort is not expressible as one path prefix. Every
+     * `lifecycle` cohort is: version-pinned pages span the whole Site, so a
+     * drill-through must fall back to the unfiltered not-indexed list.
+     */
+    readonly pathPrefix: z.ZodNullable<z.ZodString>;
+    readonly pages: z.ZodNumber;
+    readonly notIndexed: z.ZodNumber;
+    readonly notIndexedPercent: z.ZodNumber;
+    readonly restOfSitePercent: z.ZodNumber;
+    readonly restOfSitePages: z.ZodNumber;
+    readonly confidenceIntervalLower: z.ZodNumber;
+    readonly confidenceIntervalUpper: z.ZodNumber;
+    /** Families nest, so subtract this before summing notIndexed down the list. */
+    readonly alreadyCountedAbove: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    readonly family: z.ZodString;
+    readonly dimension: z.ZodString;
+    readonly pathPrefix: z.ZodNullable<z.ZodString>;
+    readonly pages: z.ZodNumber;
+    readonly notIndexed: z.ZodNumber;
+    readonly notIndexedPercent: z.ZodNumber;
+    readonly restOfSitePercent: z.ZodNumber;
+    readonly restOfSitePages: z.ZodNumber;
+    readonly confidenceIntervalLower: z.ZodNumber;
+    readonly confidenceIntervalUpper: z.ZodNumber;
+    readonly alreadyCountedAbove: z.ZodNumber;
+}, z.core.$strip>>;
+export declare const rankedCohortSchema: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
+    readonly family: z.ZodString;
+    readonly pages: z.ZodNumber;
+    readonly notIndexed: z.ZodNumber;
+    readonly notIndexedPercent: z.ZodNumber;
+    /** False means this family has NOT been shown to differ from the rest of the Site. */
+    readonly statisticallyEstablished: z.ZodBoolean;
+    readonly belowMinimumSample: z.ZodBoolean;
+}, z.core.$strip>, z.ZodObject<{
+    readonly family: z.ZodString;
+    readonly pages: z.ZodNumber;
+    readonly notIndexed: z.ZodNumber;
+    readonly notIndexedPercent: z.ZodNumber;
+    readonly statisticallyEstablished: z.ZodBoolean;
+    readonly belowMinimumSample: z.ZodBoolean;
+}, z.core.$strip>>;
+/**
+ * Two lists that mean different things and must never be merged.
+ * `established` holds only families whose Wilson score interval clears the
+ * not-indexed rate of their own complement after a Bonferroni correction; those
+ * are the only rows that may be reported as a finding. `ranked` orders every
+ * family by raw rate with no test applied, so it always answers "where is
+ * indexing worst" — a high rate there is a lead to verify, never a conclusion.
+ */
+export declare const indexCohortsDataSchema: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
+    readonly analysed: z.ZodBoolean;
+    readonly reason: z.ZodNullable<z.ZodString>;
+    readonly message: z.ZodNullable<z.ZodString>;
+    readonly asOf: z.ZodNullable<z.ZodString>;
+    readonly baseline: z.ZodNullable<z.ZodObject<{
+        pages: z.ZodNumber;
+        notIndexed: z.ZodNumber;
+        notIndexedPercent: z.ZodNumber;
+    }, z.core.$strict>>;
+    readonly coverage: z.ZodNullable<z.ZodObject<{
+        analysed: z.ZodNumber;
+        notIndexedButNeverCrawled: z.ZodNumber;
+        excludedFragments: z.ZodNumber;
+    }, z.core.$strict>>;
+    readonly method: z.ZodNullable<z.ZodString>;
+    readonly familiesTested: z.ZodNumber;
+    readonly established: z.ZodArray<z.ZodObject<{
+        readonly family: z.ZodString;
+        readonly dimension: z.ZodString;
+        /**
+         * Null when the cohort is not expressible as one path prefix. Every
+         * `lifecycle` cohort is: version-pinned pages span the whole Site, so a
+         * drill-through must fall back to the unfiltered not-indexed list.
+         */
+        readonly pathPrefix: z.ZodNullable<z.ZodString>;
+        readonly pages: z.ZodNumber;
+        readonly notIndexed: z.ZodNumber;
+        readonly notIndexedPercent: z.ZodNumber;
+        readonly restOfSitePercent: z.ZodNumber;
+        readonly restOfSitePages: z.ZodNumber;
+        readonly confidenceIntervalLower: z.ZodNumber;
+        readonly confidenceIntervalUpper: z.ZodNumber;
+        /** Families nest, so subtract this before summing notIndexed down the list. */
+        readonly alreadyCountedAbove: z.ZodNumber;
+    }, z.core.$strip>>;
+    readonly establishedNote: z.ZodNullable<z.ZodString>;
+    readonly ranked: z.ZodArray<z.ZodObject<{
+        readonly family: z.ZodString;
+        readonly pages: z.ZodNumber;
+        readonly notIndexed: z.ZodNumber;
+        readonly notIndexedPercent: z.ZodNumber;
+        /** False means this family has NOT been shown to differ from the rest of the Site. */
+        readonly statisticallyEstablished: z.ZodBoolean;
+        readonly belowMinimumSample: z.ZodBoolean;
+    }, z.core.$strip>>;
+    readonly rankedTotal: z.ZodNumber;
+    readonly minSectionPages: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    readonly analysed: z.ZodBoolean;
+    readonly reason: z.ZodNullable<z.ZodString>;
+    readonly message: z.ZodNullable<z.ZodString>;
+    readonly asOf: z.ZodNullable<z.ZodString>;
+    readonly baseline: z.ZodNullable<z.ZodObject<{
+        pages: z.ZodNumber;
+        notIndexed: z.ZodNumber;
+        notIndexedPercent: z.ZodNumber;
+    }, z.core.$loose>>;
+    readonly coverage: z.ZodNullable<z.ZodObject<{
+        analysed: z.ZodNumber;
+        notIndexedButNeverCrawled: z.ZodNumber;
+        excludedFragments: z.ZodNumber;
+    }, z.core.$loose>>;
+    readonly method: z.ZodNullable<z.ZodString>;
+    readonly familiesTested: z.ZodNumber;
+    readonly established: z.ZodArray<z.ZodObject<{
+        readonly family: z.ZodString;
+        readonly dimension: z.ZodString;
+        readonly pathPrefix: z.ZodNullable<z.ZodString>;
+        readonly pages: z.ZodNumber;
+        readonly notIndexed: z.ZodNumber;
+        readonly notIndexedPercent: z.ZodNumber;
+        readonly restOfSitePercent: z.ZodNumber;
+        readonly restOfSitePages: z.ZodNumber;
+        readonly confidenceIntervalLower: z.ZodNumber;
+        readonly confidenceIntervalUpper: z.ZodNumber;
+        readonly alreadyCountedAbove: z.ZodNumber;
+    }, z.core.$strip>>;
+    readonly establishedNote: z.ZodNullable<z.ZodString>;
+    readonly ranked: z.ZodArray<z.ZodObject<{
+        readonly family: z.ZodString;
+        readonly pages: z.ZodNumber;
+        readonly notIndexed: z.ZodNumber;
+        readonly notIndexedPercent: z.ZodNumber;
+        readonly statisticallyEstablished: z.ZodBoolean;
+        readonly belowMinimumSample: z.ZodBoolean;
+    }, z.core.$strip>>;
+    readonly rankedTotal: z.ZodNumber;
+    readonly minSectionPages: z.ZodNumber;
+}, z.core.$strip>>;
+export declare const indexCohortsResponseEnvelopeSchema: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
+    data: z.ZodObject<{
+        readonly analysed: z.ZodBoolean;
+        readonly reason: z.ZodNullable<z.ZodString>;
+        readonly message: z.ZodNullable<z.ZodString>;
+        readonly asOf: z.ZodNullable<z.ZodString>;
+        readonly baseline: z.ZodNullable<z.ZodObject<{
+            pages: z.ZodNumber;
+            notIndexed: z.ZodNumber;
+            notIndexedPercent: z.ZodNumber;
+        }, z.core.$strict>>;
+        readonly coverage: z.ZodNullable<z.ZodObject<{
+            analysed: z.ZodNumber;
+            notIndexedButNeverCrawled: z.ZodNumber;
+            excludedFragments: z.ZodNumber;
+        }, z.core.$strict>>;
+        readonly method: z.ZodNullable<z.ZodString>;
+        readonly familiesTested: z.ZodNumber;
+        readonly established: z.ZodArray<z.ZodObject<{
+            readonly family: z.ZodString;
+            readonly dimension: z.ZodString;
+            /**
+             * Null when the cohort is not expressible as one path prefix. Every
+             * `lifecycle` cohort is: version-pinned pages span the whole Site, so a
+             * drill-through must fall back to the unfiltered not-indexed list.
+             */
+            readonly pathPrefix: z.ZodNullable<z.ZodString>;
+            readonly pages: z.ZodNumber;
+            readonly notIndexed: z.ZodNumber;
+            readonly notIndexedPercent: z.ZodNumber;
+            readonly restOfSitePercent: z.ZodNumber;
+            readonly restOfSitePages: z.ZodNumber;
+            readonly confidenceIntervalLower: z.ZodNumber;
+            readonly confidenceIntervalUpper: z.ZodNumber;
+            /** Families nest, so subtract this before summing notIndexed down the list. */
+            readonly alreadyCountedAbove: z.ZodNumber;
+        }, z.core.$strip>>;
+        readonly establishedNote: z.ZodNullable<z.ZodString>;
+        readonly ranked: z.ZodArray<z.ZodObject<{
+            readonly family: z.ZodString;
+            readonly pages: z.ZodNumber;
+            readonly notIndexed: z.ZodNumber;
+            readonly notIndexedPercent: z.ZodNumber;
+            /** False means this family has NOT been shown to differ from the rest of the Site. */
+            readonly statisticallyEstablished: z.ZodBoolean;
+            readonly belowMinimumSample: z.ZodBoolean;
+        }, z.core.$strip>>;
+        readonly rankedTotal: z.ZodNumber;
+        readonly minSectionPages: z.ZodNumber;
+    }, z.core.$strip>;
+    meta: z.ZodObject<{
+        requestId: z.ZodString;
+        version: z.ZodLiteral<"1.0">;
+    }, z.core.$strict>;
+}, z.core.$strip>, z.ZodObject<{
+    data: z.ZodObject<{
+        readonly analysed: z.ZodBoolean;
+        readonly reason: z.ZodNullable<z.ZodString>;
+        readonly message: z.ZodNullable<z.ZodString>;
+        readonly asOf: z.ZodNullable<z.ZodString>;
+        readonly baseline: z.ZodNullable<z.ZodObject<{
+            pages: z.ZodNumber;
+            notIndexed: z.ZodNumber;
+            notIndexedPercent: z.ZodNumber;
+        }, z.core.$loose>>;
+        readonly coverage: z.ZodNullable<z.ZodObject<{
+            analysed: z.ZodNumber;
+            notIndexedButNeverCrawled: z.ZodNumber;
+            excludedFragments: z.ZodNumber;
+        }, z.core.$loose>>;
+        readonly method: z.ZodNullable<z.ZodString>;
+        readonly familiesTested: z.ZodNumber;
+        readonly established: z.ZodArray<z.ZodObject<{
+            readonly family: z.ZodString;
+            readonly dimension: z.ZodString;
+            readonly pathPrefix: z.ZodNullable<z.ZodString>;
+            readonly pages: z.ZodNumber;
+            readonly notIndexed: z.ZodNumber;
+            readonly notIndexedPercent: z.ZodNumber;
+            readonly restOfSitePercent: z.ZodNumber;
+            readonly restOfSitePages: z.ZodNumber;
+            readonly confidenceIntervalLower: z.ZodNumber;
+            readonly confidenceIntervalUpper: z.ZodNumber;
+            readonly alreadyCountedAbove: z.ZodNumber;
+        }, z.core.$strip>>;
+        readonly establishedNote: z.ZodNullable<z.ZodString>;
+        readonly ranked: z.ZodArray<z.ZodObject<{
+            readonly family: z.ZodString;
+            readonly pages: z.ZodNumber;
+            readonly notIndexed: z.ZodNumber;
+            readonly notIndexedPercent: z.ZodNumber;
+            readonly statisticallyEstablished: z.ZodBoolean;
+            readonly belowMinimumSample: z.ZodBoolean;
+        }, z.core.$strip>>;
+        readonly rankedTotal: z.ZodNumber;
+        readonly minSectionPages: z.ZodNumber;
+    }, z.core.$strip>;
+    meta: z.ZodObject<{
+        requestId: z.ZodString;
+        version: z.ZodLiteral<"1.0">;
+    }, z.core.$loose>;
+}, z.core.$strip>>;
+export type IndexCohorts = z.output<typeof indexCohortsDataSchema.producer>;
+export declare const indexCohortsReadOperation: {
+    readonly id: 'sites.search.indexing.cohorts.read';
+    readonly method: 'GET';
+    readonly path: '/api/v1/sites/{siteId}/search/indexing/cohorts';
+    readonly visibility: 'public';
+    readonly semantics: {
+        readonly kind: 'query';
+        readonly sideEffects: 'none';
+        readonly retry: 'idempotent';
+        readonly readConsistency: 'primary';
+    };
+    readonly auth: {
+        readonly credentials: readonly ["session", "api_token"];
+        readonly scopes: readonly ["sites:read"];
+        readonly minimumRole: 'viewer';
+        readonly ownership: 'site';
+    };
+    readonly request: {
+        readonly params: z.ZodObject<{
+            siteId: z.ZodString;
+        }, z.core.$strict>;
+        readonly query: z.ZodObject<{
+            limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+            minSectionPages: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+        }, z.core.$strict>;
+        readonly headers: null;
+        readonly body: null;
+    };
+    readonly responses: {
+        readonly 200: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
+            data: z.ZodObject<{
+                readonly analysed: z.ZodBoolean;
+                readonly reason: z.ZodNullable<z.ZodString>;
+                readonly message: z.ZodNullable<z.ZodString>;
+                readonly asOf: z.ZodNullable<z.ZodString>;
+                readonly baseline: z.ZodNullable<z.ZodObject<{
+                    pages: z.ZodNumber;
+                    notIndexed: z.ZodNumber;
+                    notIndexedPercent: z.ZodNumber;
+                }, z.core.$strict>>;
+                readonly coverage: z.ZodNullable<z.ZodObject<{
+                    analysed: z.ZodNumber;
+                    notIndexedButNeverCrawled: z.ZodNumber;
+                    excludedFragments: z.ZodNumber;
+                }, z.core.$strict>>;
+                readonly method: z.ZodNullable<z.ZodString>;
+                readonly familiesTested: z.ZodNumber;
+                readonly established: z.ZodArray<z.ZodObject<{
+                    readonly family: z.ZodString;
+                    readonly dimension: z.ZodString;
+                    /**
+                     * Null when the cohort is not expressible as one path prefix. Every
+                     * `lifecycle` cohort is: version-pinned pages span the whole Site, so a
+                     * drill-through must fall back to the unfiltered not-indexed list.
+                     */
+                    readonly pathPrefix: z.ZodNullable<z.ZodString>;
+                    readonly pages: z.ZodNumber;
+                    readonly notIndexed: z.ZodNumber;
+                    readonly notIndexedPercent: z.ZodNumber;
+                    readonly restOfSitePercent: z.ZodNumber;
+                    readonly restOfSitePages: z.ZodNumber;
+                    readonly confidenceIntervalLower: z.ZodNumber;
+                    readonly confidenceIntervalUpper: z.ZodNumber;
+                    /** Families nest, so subtract this before summing notIndexed down the list. */
+                    readonly alreadyCountedAbove: z.ZodNumber;
+                }, z.core.$strip>>;
+                readonly establishedNote: z.ZodNullable<z.ZodString>;
+                readonly ranked: z.ZodArray<z.ZodObject<{
+                    readonly family: z.ZodString;
+                    readonly pages: z.ZodNumber;
+                    readonly notIndexed: z.ZodNumber;
+                    readonly notIndexedPercent: z.ZodNumber;
+                    /** False means this family has NOT been shown to differ from the rest of the Site. */
+                    readonly statisticallyEstablished: z.ZodBoolean;
+                    readonly belowMinimumSample: z.ZodBoolean;
+                }, z.core.$strip>>;
+                readonly rankedTotal: z.ZodNumber;
+                readonly minSectionPages: z.ZodNumber;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+                requestId: z.ZodString;
+                version: z.ZodLiteral<"1.0">;
+            }, z.core.$strict>;
+        }, z.core.$strip>, z.ZodObject<{
+            data: z.ZodObject<{
+                readonly analysed: z.ZodBoolean;
+                readonly reason: z.ZodNullable<z.ZodString>;
+                readonly message: z.ZodNullable<z.ZodString>;
+                readonly asOf: z.ZodNullable<z.ZodString>;
+                readonly baseline: z.ZodNullable<z.ZodObject<{
+                    pages: z.ZodNumber;
+                    notIndexed: z.ZodNumber;
+                    notIndexedPercent: z.ZodNumber;
+                }, z.core.$loose>>;
+                readonly coverage: z.ZodNullable<z.ZodObject<{
+                    analysed: z.ZodNumber;
+                    notIndexedButNeverCrawled: z.ZodNumber;
+                    excludedFragments: z.ZodNumber;
+                }, z.core.$loose>>;
+                readonly method: z.ZodNullable<z.ZodString>;
+                readonly familiesTested: z.ZodNumber;
+                readonly established: z.ZodArray<z.ZodObject<{
+                    readonly family: z.ZodString;
+                    readonly dimension: z.ZodString;
+                    readonly pathPrefix: z.ZodNullable<z.ZodString>;
+                    readonly pages: z.ZodNumber;
+                    readonly notIndexed: z.ZodNumber;
+                    readonly notIndexedPercent: z.ZodNumber;
+                    readonly restOfSitePercent: z.ZodNumber;
+                    readonly restOfSitePages: z.ZodNumber;
+                    readonly confidenceIntervalLower: z.ZodNumber;
+                    readonly confidenceIntervalUpper: z.ZodNumber;
+                    readonly alreadyCountedAbove: z.ZodNumber;
+                }, z.core.$strip>>;
+                readonly establishedNote: z.ZodNullable<z.ZodString>;
+                readonly ranked: z.ZodArray<z.ZodObject<{
+                    readonly family: z.ZodString;
+                    readonly pages: z.ZodNumber;
+                    readonly notIndexed: z.ZodNumber;
+                    readonly notIndexedPercent: z.ZodNumber;
+                    readonly statisticallyEstablished: z.ZodBoolean;
+                    readonly belowMinimumSample: z.ZodBoolean;
+                }, z.core.$strip>>;
+                readonly rankedTotal: z.ZodNumber;
+                readonly minSectionPages: z.ZodNumber;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+                requestId: z.ZodString;
+                version: z.ZodLiteral<"1.0">;
+            }, z.core.$loose>;
+        }, z.core.$strip>>;
+    };
+    readonly errors: readonly ["invalid_request", "unauthorized", "auth_expired", "forbidden", "not_found", "entitlement_required", "conflict", "rate_limited", "contract_violation", "internal_error"];
+    readonly errorResponse: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
+        readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+                auth_expired: "auth_expired";
+                conflict: "conflict";
+                contract_violation: "contract_violation";
+                entitlement_required: "entitlement_required";
+                forbidden: "forbidden";
+                internal_error: "internal_error";
+                invalid_request: "invalid_request";
+                not_found: "not_found";
+                provider_unavailable: "provider_unavailable";
+                quota_exhausted: "quota_exhausted";
+                rate_limited: "rate_limited";
+                site_ambiguous: "site_ambiguous";
+                stale_evidence: "stale_evidence";
+                unauthorized: "unauthorized";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strict>;
+    }, z.core.$strip>, z.ZodObject<{
+        readonly error: z.ZodObject<{
+            code: z.ZodEnum<{
+                auth_expired: "auth_expired";
+                conflict: "conflict";
+                contract_violation: "contract_violation";
+                entitlement_required: "entitlement_required";
+                forbidden: "forbidden";
+                internal_error: "internal_error";
+                invalid_request: "invalid_request";
+                not_found: "not_found";
+                provider_unavailable: "provider_unavailable";
+                quota_exhausted: "quota_exhausted";
+                rate_limited: "rate_limited";
+                site_ambiguous: "site_ambiguous";
+                stale_evidence: "stale_evidence";
+                unauthorized: "unauthorized";
+            }>;
+            message: z.ZodString;
+            requestId: z.ZodString;
+            retryable: z.ZodBoolean;
+            details: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$loose>;
+    }, z.core.$strip>>;
+    readonly resources: {
+        readonly reads: readonly [{
+            readonly type: 'site.collection';
+            readonly idFrom: 'params.siteId';
+        }];
+        readonly changes: readonly [];
+    };
+    readonly policy: {
+        readonly rate: {
+            readonly name: 'public-v1-fixed-window';
+            readonly limit: 50;
+            readonly windowSeconds: 60;
+        };
+        readonly idempotency: {
+            readonly _tag: 'none';
+        };
+        readonly entitlement: null;
+        readonly meter: null;
+    };
+    readonly lifecycle: {
+        readonly introduced: '1.2.0';
+    };
+    readonly docs: {
+        readonly summary: 'Read indexing by route family';
+        readonly description: 'Returns the not-indexed rate per route family, joined from the Site crawl to Google per-URL index state, so an indexing failure that clusters in one template surfaces as one finding instead of many page-level ones. Read it before listing individual not-indexed URLs. `established` holds only families proven worse than the rest of the Site after a Bonferroni correction; `ranked` orders every family by raw rate with no test applied and is leads only. `analysed: false` means there is no completed crawl or no index state to join, which is not the same as healthy indexing.';
+        readonly tags: readonly ["Search Console"];
+        readonly examples: readonly [{
+            readonly request: {
+                readonly params: {
+                    readonly siteId: 'site_01JXYZ';
+                };
+                readonly query: {
+                    readonly limit: 12;
+                    readonly minSectionPages: 5;
+                };
+            };
+            readonly response: {
+                readonly status: 200;
+                readonly body: {
+                    readonly data: {
+                        readonly analysed: true;
+                        readonly reason: null;
+                        readonly message: null;
+                        readonly asOf: '2026-09-01T00:00:00.000Z';
+                        readonly baseline: {
+                            readonly pages: 1200;
+                            readonly notIndexed: 180;
+                            readonly notIndexedPercent: 15;
+                        };
+                        readonly coverage: {
+                            readonly analysed: 1200;
+                            readonly notIndexedButNeverCrawled: 40;
+                            readonly excludedFragments: 2;
+                        };
+                        readonly method: 'Wilson score interval per family against its own complement, Bonferroni-corrected across 9 tested families (critical value z=2.77).';
+                        readonly familiesTested: 9;
+                        readonly established: readonly [{
+                            readonly family: '/docs';
+                            readonly dimension: 'depth-1';
+                            readonly pathPrefix: '/docs';
+                            readonly pages: 420;
+                            readonly notIndexed: 150;
+                            readonly notIndexedPercent: 35.7;
+                            readonly restOfSitePercent: 3.8;
+                            readonly restOfSitePages: 780;
+                            readonly confidenceIntervalLower: 31.2;
+                            readonly confidenceIntervalUpper: 40.4;
+                            readonly alreadyCountedAbove: 0;
+                        }];
+                        readonly establishedNote: null;
+                        readonly ranked: readonly [{
+                            readonly family: '/docs';
+                            readonly pages: 420;
+                            readonly notIndexed: 150;
+                            readonly notIndexedPercent: 35.7;
+                            readonly statisticallyEstablished: true;
+                            readonly belowMinimumSample: false;
+                        }];
+                        readonly rankedTotal: 9;
+                        readonly minSectionPages: 5;
+                    };
+                    readonly meta: {
+                        readonly requestId: 'req_01JXYZ';
+                        readonly version: '1.0';
+                    };
+                };
+            };
+        }];
+    };
+};
 export declare const searchV1Registry: import("./core.js").PublicV1Registry<{
     readonly queryAnalytics: {
         readonly visibility: 'public';
@@ -5593,6 +6115,276 @@ export declare const searchV1Registry: import("./core.js").PublicV1Registry<{
             }];
         };
     };
+    readonly readIndexingCohorts: {
+        readonly id: 'sites.search.indexing.cohorts.read';
+        readonly method: 'GET';
+        readonly path: '/api/v1/sites/{siteId}/search/indexing/cohorts';
+        readonly visibility: 'public';
+        readonly semantics: {
+            readonly kind: 'query';
+            readonly sideEffects: 'none';
+            readonly retry: 'idempotent';
+            readonly readConsistency: 'primary';
+        };
+        readonly auth: {
+            readonly credentials: readonly ["session", "api_token"];
+            readonly scopes: readonly ["sites:read"];
+            readonly minimumRole: 'viewer';
+            readonly ownership: 'site';
+        };
+        readonly request: {
+            readonly params: z.ZodObject<{
+                siteId: z.ZodString;
+            }, z.core.$strict>;
+            readonly query: z.ZodObject<{
+                limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+                minSectionPages: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+            }, z.core.$strict>;
+            readonly headers: null;
+            readonly body: null;
+        };
+        readonly responses: {
+            readonly 200: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
+                data: z.ZodObject<{
+                    readonly analysed: z.ZodBoolean;
+                    readonly reason: z.ZodNullable<z.ZodString>;
+                    readonly message: z.ZodNullable<z.ZodString>;
+                    readonly asOf: z.ZodNullable<z.ZodString>;
+                    readonly baseline: z.ZodNullable<z.ZodObject<{
+                        pages: z.ZodNumber;
+                        notIndexed: z.ZodNumber;
+                        notIndexedPercent: z.ZodNumber;
+                    }, z.core.$strict>>;
+                    readonly coverage: z.ZodNullable<z.ZodObject<{
+                        analysed: z.ZodNumber;
+                        notIndexedButNeverCrawled: z.ZodNumber;
+                        excludedFragments: z.ZodNumber;
+                    }, z.core.$strict>>;
+                    readonly method: z.ZodNullable<z.ZodString>;
+                    readonly familiesTested: z.ZodNumber;
+                    readonly established: z.ZodArray<z.ZodObject<{
+                        readonly family: z.ZodString;
+                        readonly dimension: z.ZodString;
+                        /**
+                         * Null when the cohort is not expressible as one path prefix. Every
+                         * `lifecycle` cohort is: version-pinned pages span the whole Site, so a
+                         * drill-through must fall back to the unfiltered not-indexed list.
+                         */
+                        readonly pathPrefix: z.ZodNullable<z.ZodString>;
+                        readonly pages: z.ZodNumber;
+                        readonly notIndexed: z.ZodNumber;
+                        readonly notIndexedPercent: z.ZodNumber;
+                        readonly restOfSitePercent: z.ZodNumber;
+                        readonly restOfSitePages: z.ZodNumber;
+                        readonly confidenceIntervalLower: z.ZodNumber;
+                        readonly confidenceIntervalUpper: z.ZodNumber;
+                        /** Families nest, so subtract this before summing notIndexed down the list. */
+                        readonly alreadyCountedAbove: z.ZodNumber;
+                    }, z.core.$strip>>;
+                    readonly establishedNote: z.ZodNullable<z.ZodString>;
+                    readonly ranked: z.ZodArray<z.ZodObject<{
+                        readonly family: z.ZodString;
+                        readonly pages: z.ZodNumber;
+                        readonly notIndexed: z.ZodNumber;
+                        readonly notIndexedPercent: z.ZodNumber;
+                        /** False means this family has NOT been shown to differ from the rest of the Site. */
+                        readonly statisticallyEstablished: z.ZodBoolean;
+                        readonly belowMinimumSample: z.ZodBoolean;
+                    }, z.core.$strip>>;
+                    readonly rankedTotal: z.ZodNumber;
+                    readonly minSectionPages: z.ZodNumber;
+                }, z.core.$strip>;
+                meta: z.ZodObject<{
+                    requestId: z.ZodString;
+                    version: z.ZodLiteral<"1.0">;
+                }, z.core.$strict>;
+            }, z.core.$strip>, z.ZodObject<{
+                data: z.ZodObject<{
+                    readonly analysed: z.ZodBoolean;
+                    readonly reason: z.ZodNullable<z.ZodString>;
+                    readonly message: z.ZodNullable<z.ZodString>;
+                    readonly asOf: z.ZodNullable<z.ZodString>;
+                    readonly baseline: z.ZodNullable<z.ZodObject<{
+                        pages: z.ZodNumber;
+                        notIndexed: z.ZodNumber;
+                        notIndexedPercent: z.ZodNumber;
+                    }, z.core.$loose>>;
+                    readonly coverage: z.ZodNullable<z.ZodObject<{
+                        analysed: z.ZodNumber;
+                        notIndexedButNeverCrawled: z.ZodNumber;
+                        excludedFragments: z.ZodNumber;
+                    }, z.core.$loose>>;
+                    readonly method: z.ZodNullable<z.ZodString>;
+                    readonly familiesTested: z.ZodNumber;
+                    readonly established: z.ZodArray<z.ZodObject<{
+                        readonly family: z.ZodString;
+                        readonly dimension: z.ZodString;
+                        readonly pathPrefix: z.ZodNullable<z.ZodString>;
+                        readonly pages: z.ZodNumber;
+                        readonly notIndexed: z.ZodNumber;
+                        readonly notIndexedPercent: z.ZodNumber;
+                        readonly restOfSitePercent: z.ZodNumber;
+                        readonly restOfSitePages: z.ZodNumber;
+                        readonly confidenceIntervalLower: z.ZodNumber;
+                        readonly confidenceIntervalUpper: z.ZodNumber;
+                        readonly alreadyCountedAbove: z.ZodNumber;
+                    }, z.core.$strip>>;
+                    readonly establishedNote: z.ZodNullable<z.ZodString>;
+                    readonly ranked: z.ZodArray<z.ZodObject<{
+                        readonly family: z.ZodString;
+                        readonly pages: z.ZodNumber;
+                        readonly notIndexed: z.ZodNumber;
+                        readonly notIndexedPercent: z.ZodNumber;
+                        readonly statisticallyEstablished: z.ZodBoolean;
+                        readonly belowMinimumSample: z.ZodBoolean;
+                    }, z.core.$strip>>;
+                    readonly rankedTotal: z.ZodNumber;
+                    readonly minSectionPages: z.ZodNumber;
+                }, z.core.$strip>;
+                meta: z.ZodObject<{
+                    requestId: z.ZodString;
+                    version: z.ZodLiteral<"1.0">;
+                }, z.core.$loose>;
+            }, z.core.$strip>>;
+        };
+        readonly errors: readonly ["invalid_request", "unauthorized", "auth_expired", "forbidden", "not_found", "entitlement_required", "conflict", "rate_limited", "contract_violation", "internal_error"];
+        readonly errorResponse: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
+            readonly error: z.ZodObject<{
+                code: z.ZodEnum<{
+                    auth_expired: "auth_expired";
+                    conflict: "conflict";
+                    contract_violation: "contract_violation";
+                    entitlement_required: "entitlement_required";
+                    forbidden: "forbidden";
+                    internal_error: "internal_error";
+                    invalid_request: "invalid_request";
+                    not_found: "not_found";
+                    provider_unavailable: "provider_unavailable";
+                    quota_exhausted: "quota_exhausted";
+                    rate_limited: "rate_limited";
+                    site_ambiguous: "site_ambiguous";
+                    stale_evidence: "stale_evidence";
+                    unauthorized: "unauthorized";
+                }>;
+                message: z.ZodString;
+                requestId: z.ZodString;
+                retryable: z.ZodBoolean;
+                details: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strict>;
+        }, z.core.$strip>, z.ZodObject<{
+            readonly error: z.ZodObject<{
+                code: z.ZodEnum<{
+                    auth_expired: "auth_expired";
+                    conflict: "conflict";
+                    contract_violation: "contract_violation";
+                    entitlement_required: "entitlement_required";
+                    forbidden: "forbidden";
+                    internal_error: "internal_error";
+                    invalid_request: "invalid_request";
+                    not_found: "not_found";
+                    provider_unavailable: "provider_unavailable";
+                    quota_exhausted: "quota_exhausted";
+                    rate_limited: "rate_limited";
+                    site_ambiguous: "site_ambiguous";
+                    stale_evidence: "stale_evidence";
+                    unauthorized: "unauthorized";
+                }>;
+                message: z.ZodString;
+                requestId: z.ZodString;
+                retryable: z.ZodBoolean;
+                details: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$loose>;
+        }, z.core.$strip>>;
+        readonly resources: {
+            readonly reads: readonly [{
+                readonly type: 'site.collection';
+                readonly idFrom: 'params.siteId';
+            }];
+            readonly changes: readonly [];
+        };
+        readonly policy: {
+            readonly rate: {
+                readonly name: 'public-v1-fixed-window';
+                readonly limit: 50;
+                readonly windowSeconds: 60;
+            };
+            readonly idempotency: {
+                readonly _tag: 'none';
+            };
+            readonly entitlement: null;
+            readonly meter: null;
+        };
+        readonly lifecycle: {
+            readonly introduced: '1.2.0';
+        };
+        readonly docs: {
+            readonly summary: 'Read indexing by route family';
+            readonly description: 'Returns the not-indexed rate per route family, joined from the Site crawl to Google per-URL index state, so an indexing failure that clusters in one template surfaces as one finding instead of many page-level ones. Read it before listing individual not-indexed URLs. `established` holds only families proven worse than the rest of the Site after a Bonferroni correction; `ranked` orders every family by raw rate with no test applied and is leads only. `analysed: false` means there is no completed crawl or no index state to join, which is not the same as healthy indexing.';
+            readonly tags: readonly ["Search Console"];
+            readonly examples: readonly [{
+                readonly request: {
+                    readonly params: {
+                        readonly siteId: 'site_01JXYZ';
+                    };
+                    readonly query: {
+                        readonly limit: 12;
+                        readonly minSectionPages: 5;
+                    };
+                };
+                readonly response: {
+                    readonly status: 200;
+                    readonly body: {
+                        readonly data: {
+                            readonly analysed: true;
+                            readonly reason: null;
+                            readonly message: null;
+                            readonly asOf: '2026-09-01T00:00:00.000Z';
+                            readonly baseline: {
+                                readonly pages: 1200;
+                                readonly notIndexed: 180;
+                                readonly notIndexedPercent: 15;
+                            };
+                            readonly coverage: {
+                                readonly analysed: 1200;
+                                readonly notIndexedButNeverCrawled: 40;
+                                readonly excludedFragments: 2;
+                            };
+                            readonly method: 'Wilson score interval per family against its own complement, Bonferroni-corrected across 9 tested families (critical value z=2.77).';
+                            readonly familiesTested: 9;
+                            readonly established: readonly [{
+                                readonly family: '/docs';
+                                readonly dimension: 'depth-1';
+                                readonly pathPrefix: '/docs';
+                                readonly pages: 420;
+                                readonly notIndexed: 150;
+                                readonly notIndexedPercent: 35.7;
+                                readonly restOfSitePercent: 3.8;
+                                readonly restOfSitePages: 780;
+                                readonly confidenceIntervalLower: 31.2;
+                                readonly confidenceIntervalUpper: 40.4;
+                                readonly alreadyCountedAbove: 0;
+                            }];
+                            readonly establishedNote: null;
+                            readonly ranked: readonly [{
+                                readonly family: '/docs';
+                                readonly pages: 420;
+                                readonly notIndexed: 150;
+                                readonly notIndexedPercent: 35.7;
+                                readonly statisticallyEstablished: true;
+                                readonly belowMinimumSample: false;
+                            }];
+                            readonly rankedTotal: 9;
+                            readonly minSectionPages: 5;
+                        };
+                        readonly meta: {
+                            readonly requestId: 'req_01JXYZ';
+                            readonly version: '1.0';
+                        };
+                    };
+                };
+            }];
+        };
+    };
 }>;
 export type SearchAnalyticsQuery = z.input<typeof searchAnalyticsQuerySchema>;
 export type SearchAnalyticsData = z.output<typeof searchAnalyticsDataSchema.client>;