@nuxtseo/protocol 0.5.7 → 0.5.8

package/dist/v1/gsc.d.ts

@@ -1,4 +1,5 @@
 import type { z } from 'zod';
+import { watchedUrlsResponseSchema } from '@gscdump/contracts';
 export declare const searchConsoleSiteParamsSchema: z.ZodObject<{
     siteId: z.ZodString;
 }, z.core.$strict>;
@@ -5165,6 +5166,316 @@ export declare const indexCohortsReadOperation: {
         }];
     };
 };
+export declare const indexingWatchesResponseSchema: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
+    data: z.ZodObject<{
+        watched: z.ZodArray<z.ZodObject<{
+            url: z.ZodString;
+            addedAt: z.ZodString;
+            dueAt: z.ZodString;
+            checkpoints: z.ZodArray<z.ZodObject<{
+                checkedAt: z.ZodString;
+                coverageState: z.ZodCatch<z.ZodEnum<{
+                    unknown_to_google: "unknown_to_google";
+                    discovered_not_indexed: "discovered_not_indexed";
+                    crawled_not_indexed: "crawled_not_indexed";
+                    indexed: "indexed";
+                    noindex: "noindex";
+                    blocked_robots: "blocked_robots";
+                    soft_404: "soft_404";
+                    not_found: "not_found";
+                    server_error: "server_error";
+                    access_denied: "access_denied";
+                    access_forbidden: "access_forbidden";
+                    blocked_4xx: "blocked_4xx";
+                    redirect: "redirect";
+                    redirect_error: "redirect_error";
+                    alternate_canonical: "alternate_canonical";
+                    duplicate_no_canonical: "duplicate_no_canonical";
+                    duplicate_google_canonical: "duplicate_google_canonical";
+                    page_removed: "page_removed";
+                    unrecognized: "unrecognized";
+                    not_reported: "not_reported";
+                }>>;
+                googleCoverageState: z.ZodNullable<z.ZodString>;
+                verdict: z.ZodNullable<z.ZodString>;
+                lastCrawlTime: z.ZodNullable<z.ZodString>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>>;
+        limit: z.ZodNumber;
+        cadenceDays: z.ZodNumber;
+        meta: z.ZodObject<{
+            siteUrl: z.ZodString;
+        }, z.core.$loose>;
+    }, z.core.$strict>;
+    meta: z.ZodObject<{
+        requestId: z.ZodString;
+        version: z.ZodLiteral<"1.0">;
+    }, z.core.$strict>;
+}, z.core.$strip>, z.ZodObject<{
+    data: z.ZodObject<{
+        watched: z.ZodArray<z.ZodObject<{
+            url: z.ZodString;
+            addedAt: z.ZodString;
+            dueAt: z.ZodString;
+            checkpoints: z.ZodArray<z.ZodObject<{
+                checkedAt: z.ZodString;
+                coverageState: z.ZodCatch<z.ZodEnum<{
+                    unknown_to_google: "unknown_to_google";
+                    discovered_not_indexed: "discovered_not_indexed";
+                    crawled_not_indexed: "crawled_not_indexed";
+                    indexed: "indexed";
+                    noindex: "noindex";
+                    blocked_robots: "blocked_robots";
+                    soft_404: "soft_404";
+                    not_found: "not_found";
+                    server_error: "server_error";
+                    access_denied: "access_denied";
+                    access_forbidden: "access_forbidden";
+                    blocked_4xx: "blocked_4xx";
+                    redirect: "redirect";
+                    redirect_error: "redirect_error";
+                    alternate_canonical: "alternate_canonical";
+                    duplicate_no_canonical: "duplicate_no_canonical";
+                    duplicate_google_canonical: "duplicate_google_canonical";
+                    page_removed: "page_removed";
+                    unrecognized: "unrecognized";
+                    not_reported: "not_reported";
+                }>>;
+                googleCoverageState: z.ZodNullable<z.ZodString>;
+                verdict: z.ZodNullable<z.ZodString>;
+                lastCrawlTime: z.ZodNullable<z.ZodString>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>>;
+        limit: z.ZodNumber;
+        cadenceDays: z.ZodNumber;
+        meta: z.ZodObject<{
+            siteUrl: z.ZodString;
+        }, z.core.$loose>;
+    }, z.core.$loose>;
+    meta: z.ZodObject<{
+        requestId: z.ZodString;
+        version: z.ZodLiteral<"1.0">;
+    }, z.core.$loose>;
+}, z.core.$strip>>;
+export type IndexingWatchesData = z.output<typeof watchedUrlsResponseSchema>;
+export declare const indexingWatchesListOperation: {
+    readonly visibility: 'public';
+    readonly semantics: {
+        readonly kind: 'query';
+        readonly sideEffects: 'none';
+        readonly retry: 'idempotent';
+        readonly readConsistency: 'replica-ok';
+    };
+    readonly auth: {
+        readonly credentials: readonly ['session', 'api_token'];
+        readonly scopes: readonly ['sites:read'];
+        readonly minimumRole: 'viewer';
+        readonly ownership: 'site';
+    };
+    readonly errors: readonly ["invalid_request", "unauthorized", "auth_expired", "forbidden", "not_found", "entitlement_required", "stale_evidence", "rate_limited", "provider_unavailable", "conflict", "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 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.0.0';
+    };
+    readonly id: 'sites.search.indexing.watches.list';
+    readonly method: 'GET';
+    readonly path: '/api/v1/sites/{siteId}/search/indexing/watches';
+    readonly request: {
+        readonly params: z.ZodObject<{
+            siteId: z.ZodString;
+        }, z.core.$strict>;
+        readonly query: null;
+        readonly headers: null;
+        readonly body: null;
+    };
+    readonly responses: {
+        readonly 200: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
+            data: z.ZodObject<{
+                watched: z.ZodArray<z.ZodObject<{
+                    url: z.ZodString;
+                    addedAt: z.ZodString;
+                    dueAt: z.ZodString;
+                    checkpoints: z.ZodArray<z.ZodObject<{
+                        checkedAt: z.ZodString;
+                        coverageState: z.ZodCatch<z.ZodEnum<{
+                            unknown_to_google: "unknown_to_google";
+                            discovered_not_indexed: "discovered_not_indexed";
+                            crawled_not_indexed: "crawled_not_indexed";
+                            indexed: "indexed";
+                            noindex: "noindex";
+                            blocked_robots: "blocked_robots";
+                            soft_404: "soft_404";
+                            not_found: "not_found";
+                            server_error: "server_error";
+                            access_denied: "access_denied";
+                            access_forbidden: "access_forbidden";
+                            blocked_4xx: "blocked_4xx";
+                            redirect: "redirect";
+                            redirect_error: "redirect_error";
+                            alternate_canonical: "alternate_canonical";
+                            duplicate_no_canonical: "duplicate_no_canonical";
+                            duplicate_google_canonical: "duplicate_google_canonical";
+                            page_removed: "page_removed";
+                            unrecognized: "unrecognized";
+                            not_reported: "not_reported";
+                        }>>;
+                        googleCoverageState: z.ZodNullable<z.ZodString>;
+                        verdict: z.ZodNullable<z.ZodString>;
+                        lastCrawlTime: z.ZodNullable<z.ZodString>;
+                    }, z.core.$loose>>;
+                }, z.core.$loose>>;
+                limit: z.ZodNumber;
+                cadenceDays: z.ZodNumber;
+                meta: z.ZodObject<{
+                    siteUrl: z.ZodString;
+                }, z.core.$loose>;
+            }, z.core.$strict>;
+            meta: z.ZodObject<{
+                requestId: z.ZodString;
+                version: z.ZodLiteral<"1.0">;
+            }, z.core.$strict>;
+        }, z.core.$strip>, z.ZodObject<{
+            data: z.ZodObject<{
+                watched: z.ZodArray<z.ZodObject<{
+                    url: z.ZodString;
+                    addedAt: z.ZodString;
+                    dueAt: z.ZodString;
+                    checkpoints: z.ZodArray<z.ZodObject<{
+                        checkedAt: z.ZodString;
+                        coverageState: z.ZodCatch<z.ZodEnum<{
+                            unknown_to_google: "unknown_to_google";
+                            discovered_not_indexed: "discovered_not_indexed";
+                            crawled_not_indexed: "crawled_not_indexed";
+                            indexed: "indexed";
+                            noindex: "noindex";
+                            blocked_robots: "blocked_robots";
+                            soft_404: "soft_404";
+                            not_found: "not_found";
+                            server_error: "server_error";
+                            access_denied: "access_denied";
+                            access_forbidden: "access_forbidden";
+                            blocked_4xx: "blocked_4xx";
+                            redirect: "redirect";
+                            redirect_error: "redirect_error";
+                            alternate_canonical: "alternate_canonical";
+                            duplicate_no_canonical: "duplicate_no_canonical";
+                            duplicate_google_canonical: "duplicate_google_canonical";
+                            page_removed: "page_removed";
+                            unrecognized: "unrecognized";
+                            not_reported: "not_reported";
+                        }>>;
+                        googleCoverageState: z.ZodNullable<z.ZodString>;
+                        verdict: z.ZodNullable<z.ZodString>;
+                        lastCrawlTime: z.ZodNullable<z.ZodString>;
+                    }, z.core.$loose>>;
+                }, z.core.$loose>>;
+                limit: z.ZodNumber;
+                cadenceDays: z.ZodNumber;
+                meta: z.ZodObject<{
+                    siteUrl: z.ZodString;
+                }, z.core.$loose>;
+            }, z.core.$loose>;
+            meta: z.ZodObject<{
+                requestId: z.ZodString;
+                version: z.ZodLiteral<"1.0">;
+            }, z.core.$loose>;
+        }, z.core.$strip>>;
+    };
+    readonly resources: {
+        readonly reads: readonly [{
+            readonly type: 'site.page';
+            readonly idFrom: 'params.siteId';
+        }];
+        readonly changes: readonly [];
+    };
+    readonly docs: {
+        readonly summary: 'List Site Watched URLs';
+        readonly description: 'Returns retained Watched URLs, scheduled due times, and Checkpoints. An empty list means no retained Checkpoint for this watch.';
+        readonly tags: readonly ["Sites", "Search", "Indexing"];
+        readonly examples: readonly [{
+            readonly request: {
+                readonly params: {
+                    readonly siteId: 'site_01JXYZ';
+                };
+            };
+            readonly response: {
+                readonly status: 200;
+                readonly body: {
+                    readonly data: {
+                        readonly watched: readonly [];
+                        readonly limit: 20;
+                        readonly cadenceDays: 7;
+                        readonly meta: {
+                            readonly siteUrl: 'https://example.com';
+                        };
+                    };
+                    readonly meta: {
+                        readonly requestId: 'req_01JXYZ';
+                        readonly version: '1.0';
+                    };
+                };
+            };
+        }];
+    };
+};
 export declare const searchV1Registry: import("./core.js").PublicV1Registry<{
     readonly queryAnalytics: {
         readonly visibility: 'public';
@@ -7568,6 +7879,224 @@ export declare const searchV1Registry: import("./core.js").PublicV1Registry<{
             }];
         };
     };
+    readonly listWatches: {
+        readonly visibility: 'public';
+        readonly semantics: {
+            readonly kind: 'query';
+            readonly sideEffects: 'none';
+            readonly retry: 'idempotent';
+            readonly readConsistency: 'replica-ok';
+        };
+        readonly auth: {
+            readonly credentials: readonly ['session', 'api_token'];
+            readonly scopes: readonly ['sites:read'];
+            readonly minimumRole: 'viewer';
+            readonly ownership: 'site';
+        };
+        readonly errors: readonly ["invalid_request", "unauthorized", "auth_expired", "forbidden", "not_found", "entitlement_required", "stale_evidence", "rate_limited", "provider_unavailable", "conflict", "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 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.0.0';
+        };
+        readonly id: 'sites.search.indexing.watches.list';
+        readonly method: 'GET';
+        readonly path: '/api/v1/sites/{siteId}/search/indexing/watches';
+        readonly request: {
+            readonly params: z.ZodObject<{
+                siteId: z.ZodString;
+            }, z.core.$strict>;
+            readonly query: null;
+            readonly headers: null;
+            readonly body: null;
+        };
+        readonly responses: {
+            readonly 200: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
+                data: z.ZodObject<{
+                    watched: z.ZodArray<z.ZodObject<{
+                        url: z.ZodString;
+                        addedAt: z.ZodString;
+                        dueAt: z.ZodString;
+                        checkpoints: z.ZodArray<z.ZodObject<{
+                            checkedAt: z.ZodString;
+                            coverageState: z.ZodCatch<z.ZodEnum<{
+                                unknown_to_google: "unknown_to_google";
+                                discovered_not_indexed: "discovered_not_indexed";
+                                crawled_not_indexed: "crawled_not_indexed";
+                                indexed: "indexed";
+                                noindex: "noindex";
+                                blocked_robots: "blocked_robots";
+                                soft_404: "soft_404";
+                                not_found: "not_found";
+                                server_error: "server_error";
+                                access_denied: "access_denied";
+                                access_forbidden: "access_forbidden";
+                                blocked_4xx: "blocked_4xx";
+                                redirect: "redirect";
+                                redirect_error: "redirect_error";
+                                alternate_canonical: "alternate_canonical";
+                                duplicate_no_canonical: "duplicate_no_canonical";
+                                duplicate_google_canonical: "duplicate_google_canonical";
+                                page_removed: "page_removed";
+                                unrecognized: "unrecognized";
+                                not_reported: "not_reported";
+                            }>>;
+                            googleCoverageState: z.ZodNullable<z.ZodString>;
+                            verdict: z.ZodNullable<z.ZodString>;
+                            lastCrawlTime: z.ZodNullable<z.ZodString>;
+                        }, z.core.$loose>>;
+                    }, z.core.$loose>>;
+                    limit: z.ZodNumber;
+                    cadenceDays: z.ZodNumber;
+                    meta: z.ZodObject<{
+                        siteUrl: z.ZodString;
+                    }, z.core.$loose>;
+                }, z.core.$strict>;
+                meta: z.ZodObject<{
+                    requestId: z.ZodString;
+                    version: z.ZodLiteral<"1.0">;
+                }, z.core.$strict>;
+            }, z.core.$strip>, z.ZodObject<{
+                data: z.ZodObject<{
+                    watched: z.ZodArray<z.ZodObject<{
+                        url: z.ZodString;
+                        addedAt: z.ZodString;
+                        dueAt: z.ZodString;
+                        checkpoints: z.ZodArray<z.ZodObject<{
+                            checkedAt: z.ZodString;
+                            coverageState: z.ZodCatch<z.ZodEnum<{
+                                unknown_to_google: "unknown_to_google";
+                                discovered_not_indexed: "discovered_not_indexed";
+                                crawled_not_indexed: "crawled_not_indexed";
+                                indexed: "indexed";
+                                noindex: "noindex";
+                                blocked_robots: "blocked_robots";
+                                soft_404: "soft_404";
+                                not_found: "not_found";
+                                server_error: "server_error";
+                                access_denied: "access_denied";
+                                access_forbidden: "access_forbidden";
+                                blocked_4xx: "blocked_4xx";
+                                redirect: "redirect";
+                                redirect_error: "redirect_error";
+                                alternate_canonical: "alternate_canonical";
+                                duplicate_no_canonical: "duplicate_no_canonical";
+                                duplicate_google_canonical: "duplicate_google_canonical";
+                                page_removed: "page_removed";
+                                unrecognized: "unrecognized";
+                                not_reported: "not_reported";
+                            }>>;
+                            googleCoverageState: z.ZodNullable<z.ZodString>;
+                            verdict: z.ZodNullable<z.ZodString>;
+                            lastCrawlTime: z.ZodNullable<z.ZodString>;
+                        }, z.core.$loose>>;
+                    }, z.core.$loose>>;
+                    limit: z.ZodNumber;
+                    cadenceDays: z.ZodNumber;
+                    meta: z.ZodObject<{
+                        siteUrl: z.ZodString;
+                    }, z.core.$loose>;
+                }, z.core.$loose>;
+                meta: z.ZodObject<{
+                    requestId: z.ZodString;
+                    version: z.ZodLiteral<"1.0">;
+                }, z.core.$loose>;
+            }, z.core.$strip>>;
+        };
+        readonly resources: {
+            readonly reads: readonly [{
+                readonly type: 'site.page';
+                readonly idFrom: 'params.siteId';
+            }];
+            readonly changes: readonly [];
+        };
+        readonly docs: {
+            readonly summary: 'List Site Watched URLs';
+            readonly description: 'Returns retained Watched URLs, scheduled due times, and Checkpoints. An empty list means no retained Checkpoint for this watch.';
+            readonly tags: readonly ["Sites", "Search", "Indexing"];
+            readonly examples: readonly [{
+                readonly request: {
+                    readonly params: {
+                        readonly siteId: 'site_01JXYZ';
+                    };
+                };
+                readonly response: {
+                    readonly status: 200;
+                    readonly body: {
+                        readonly data: {
+                            readonly watched: readonly [];
+                            readonly limit: 20;
+                            readonly cadenceDays: 7;
+                            readonly meta: {
+                                readonly siteUrl: 'https://example.com';
+                            };
+                        };
+                        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>;

package/dist/v1/gsc.js

@@ -1,4 +1,4 @@
-import { canonicalDifferenceKindSchema, gscdumpAnalysisPresetSchema, gscdumpIndexingTransitionFieldSchema, gscdumpTotalsSchema, indexingInspectResponseSchema, indexingIssueSchema, } from '@gscdump/contracts';
+import { canonicalDifferenceKindSchema, gscdumpAnalysisPresetSchema, gscdumpIndexingTransitionFieldSchema, gscdumpTotalsSchema, indexingInspectResponseSchema, indexingIssueSchema, watchedUrlsResponseSchema, } from '@gscdump/contracts';
 import { z as schema } from 'zod';
 import { defineOperation, defineRegistry, defineResponseObject, defineSuccessEnvelope, publicV1ErrorEnvelope, publicV1PageSchema, publicV1StandardRatePolicy, } from './core.js';
 export const searchConsoleSiteParamsSchema = schema.strictObject({
@@ -832,6 +832,25 @@ export const indexCohortsReadOperation = defineOperation({
             }],
     },
 });
+export const indexingWatchesResponseSchema = defineSuccessEnvelope({
+    producer: watchedUrlsResponseSchema.strict(),
+    client: watchedUrlsResponseSchema.loose(),
+});
+export const indexingWatchesListOperation = defineOperation({
+    ...common,
+    id: 'sites.search.indexing.watches.list',
+    method: 'GET',
+    path: '/api/v1/sites/{siteId}/search/indexing/watches',
+    request: { params: searchConsoleSiteParamsSchema, query: null, headers: null, body: null },
+    responses: { 200: indexingWatchesResponseSchema },
+    resources: { reads: [{ type: 'site.page', idFrom: 'params.siteId' }], changes: [] },
+    docs: {
+        summary: 'List Site Watched URLs',
+        description: 'Returns retained Watched URLs, scheduled due times, and Checkpoints. An empty list means no retained Checkpoint for this watch.',
+        tags: ['Sites', 'Search', 'Indexing'],
+        examples: [{ request: { params: { siteId: 'site_01JXYZ' } }, response: { status: 200, body: { data: { watched: [], limit: 20, cadenceDays: 7, meta: { siteUrl: 'https://example.com' } }, meta: { requestId: 'req_01JXYZ', version: '1.0' } } } }],
+    },
+});
 export const searchV1Registry = defineRegistry({
     feature: 'sites',
     operations: {
@@ -842,5 +861,6 @@ export const searchV1Registry = defineRegistry({
         readUrlInspection: urlInspectionReadOperation,
         refreshUrlInspection: urlInspectionRefreshOperation,
         readIndexingCohorts: indexCohortsReadOperation,
+        listWatches: indexingWatchesListOperation,
     },
 });