@nuxtseo/protocol 0.5.4 → 0.5.5

package/dist/v1/research.d.ts

@@ -567,6 +567,37 @@ export declare const keywordResearchQuerySchema: z.ZodObject<{
 }, z.core.$strict>;
 declare const keywordResearchDataSchema: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
     readonly topic: z.ZodString;
+    readonly topicMetrics: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        _tag: z.ZodLiteral<"measured">;
+        topic: z.ZodString;
+        metrics: z.ZodObject<{
+            readonly keyword: z.ZodString;
+            readonly volume: z.ZodNullable<z.ZodNumber>;
+            readonly difficulty: z.ZodNullable<z.ZodNumber>;
+            readonly intent: z.ZodNullable<z.ZodString>;
+            readonly secondaryIntents: z.ZodNullable<z.ZodArray<z.ZodString>>;
+            readonly cpc: z.ZodNullable<z.ZodNumber>;
+            readonly competition: z.ZodNullable<z.ZodNumber>;
+            readonly competitionLevel: z.ZodNullable<z.ZodEnum<{
+                HIGH: "HIGH";
+                LOW: "LOW";
+                MEDIUM: "MEDIUM";
+            }>>;
+            readonly lowBid: z.ZodNullable<z.ZodNumber>;
+            readonly highBid: z.ZodNullable<z.ZodNumber>;
+            readonly trend: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                readonly year: z.ZodNumber;
+                readonly month: z.ZodNumber;
+                readonly volume: z.ZodNumber;
+            }, z.core.$strip>>>;
+            readonly serpFeatures: z.ZodNullable<z.ZodArray<z.ZodString>>;
+            readonly backlinks: z.ZodNullable<z.ZodNumber>;
+            readonly referringDomains: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>;
+    }, z.core.$strict>, z.ZodObject<{
+        _tag: z.ZodLiteral<"no-data">;
+        topic: z.ZodString;
+    }, z.core.$strict>], "_tag">>;
     readonly keywords: z.ZodArray<z.ZodObject<{
         readonly keyword: z.ZodString;
         readonly volume: z.ZodNullable<z.ZodNumber>;
@@ -647,6 +678,37 @@ declare const keywordResearchDataSchema: import("./core.js").CompatibleResponseS
     }, z.core.$strict>], "_tag">;
 }, z.core.$strip>, z.ZodObject<{
     readonly topic: z.ZodString;
+    readonly topicMetrics: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        _tag: z.ZodLiteral<"measured">;
+        topic: z.ZodString;
+        metrics: z.ZodObject<{
+            readonly keyword: z.ZodString;
+            readonly volume: z.ZodNullable<z.ZodNumber>;
+            readonly difficulty: z.ZodNullable<z.ZodNumber>;
+            readonly intent: z.ZodNullable<z.ZodString>;
+            readonly secondaryIntents: z.ZodNullable<z.ZodArray<z.ZodString>>;
+            readonly cpc: z.ZodNullable<z.ZodNumber>;
+            readonly competition: z.ZodNullable<z.ZodNumber>;
+            readonly competitionLevel: z.ZodNullable<z.ZodEnum<{
+                HIGH: "HIGH";
+                LOW: "LOW";
+                MEDIUM: "MEDIUM";
+            }>>;
+            readonly lowBid: z.ZodNullable<z.ZodNumber>;
+            readonly highBid: z.ZodNullable<z.ZodNumber>;
+            readonly trend: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                readonly year: z.ZodNumber;
+                readonly month: z.ZodNumber;
+                readonly volume: z.ZodNumber;
+            }, z.core.$strip>>>;
+            readonly serpFeatures: z.ZodNullable<z.ZodArray<z.ZodString>>;
+            readonly backlinks: z.ZodNullable<z.ZodNumber>;
+            readonly referringDomains: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>;
+    }, z.core.$loose>, z.ZodObject<{
+        _tag: z.ZodLiteral<"no-data">;
+        topic: z.ZodString;
+    }, z.core.$loose>], "_tag">>;
     readonly keywords: z.ZodArray<z.ZodObject<{
         readonly keyword: z.ZodString;
         readonly volume: z.ZodNullable<z.ZodNumber>;
@@ -729,6 +791,37 @@ declare const keywordResearchDataSchema: import("./core.js").CompatibleResponseS
 export declare const keywordResearchResponseSchema: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
     data: z.ZodObject<{
         readonly topic: z.ZodString;
+        readonly topicMetrics: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            _tag: z.ZodLiteral<"measured">;
+            topic: z.ZodString;
+            metrics: z.ZodObject<{
+                readonly keyword: z.ZodString;
+                readonly volume: z.ZodNullable<z.ZodNumber>;
+                readonly difficulty: z.ZodNullable<z.ZodNumber>;
+                readonly intent: z.ZodNullable<z.ZodString>;
+                readonly secondaryIntents: z.ZodNullable<z.ZodArray<z.ZodString>>;
+                readonly cpc: z.ZodNullable<z.ZodNumber>;
+                readonly competition: z.ZodNullable<z.ZodNumber>;
+                readonly competitionLevel: z.ZodNullable<z.ZodEnum<{
+                    HIGH: "HIGH";
+                    LOW: "LOW";
+                    MEDIUM: "MEDIUM";
+                }>>;
+                readonly lowBid: z.ZodNullable<z.ZodNumber>;
+                readonly highBid: z.ZodNullable<z.ZodNumber>;
+                readonly trend: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                    readonly year: z.ZodNumber;
+                    readonly month: z.ZodNumber;
+                    readonly volume: z.ZodNumber;
+                }, z.core.$strip>>>;
+                readonly serpFeatures: z.ZodNullable<z.ZodArray<z.ZodString>>;
+                readonly backlinks: z.ZodNullable<z.ZodNumber>;
+                readonly referringDomains: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strip>;
+        }, z.core.$strict>, z.ZodObject<{
+            _tag: z.ZodLiteral<"no-data">;
+            topic: z.ZodString;
+        }, z.core.$strict>], "_tag">>;
         readonly keywords: z.ZodArray<z.ZodObject<{
             readonly keyword: z.ZodString;
             readonly volume: z.ZodNullable<z.ZodNumber>;
@@ -815,6 +908,37 @@ export declare const keywordResearchResponseSchema: import("./core.js").Compatib
 }, z.core.$strip>, z.ZodObject<{
     data: z.ZodObject<{
         readonly topic: z.ZodString;
+        readonly topicMetrics: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            _tag: z.ZodLiteral<"measured">;
+            topic: z.ZodString;
+            metrics: z.ZodObject<{
+                readonly keyword: z.ZodString;
+                readonly volume: z.ZodNullable<z.ZodNumber>;
+                readonly difficulty: z.ZodNullable<z.ZodNumber>;
+                readonly intent: z.ZodNullable<z.ZodString>;
+                readonly secondaryIntents: z.ZodNullable<z.ZodArray<z.ZodString>>;
+                readonly cpc: z.ZodNullable<z.ZodNumber>;
+                readonly competition: z.ZodNullable<z.ZodNumber>;
+                readonly competitionLevel: z.ZodNullable<z.ZodEnum<{
+                    HIGH: "HIGH";
+                    LOW: "LOW";
+                    MEDIUM: "MEDIUM";
+                }>>;
+                readonly lowBid: z.ZodNullable<z.ZodNumber>;
+                readonly highBid: z.ZodNullable<z.ZodNumber>;
+                readonly trend: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                    readonly year: z.ZodNumber;
+                    readonly month: z.ZodNumber;
+                    readonly volume: z.ZodNumber;
+                }, z.core.$strip>>>;
+                readonly serpFeatures: z.ZodNullable<z.ZodArray<z.ZodString>>;
+                readonly backlinks: z.ZodNullable<z.ZodNumber>;
+                readonly referringDomains: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strip>;
+        }, z.core.$loose>, z.ZodObject<{
+            _tag: z.ZodLiteral<"no-data">;
+            topic: z.ZodString;
+        }, z.core.$loose>], "_tag">>;
         readonly keywords: z.ZodArray<z.ZodObject<{
             readonly keyword: z.ZodString;
             readonly volume: z.ZodNullable<z.ZodNumber>;
@@ -1556,6 +1680,37 @@ export declare const keywordResearchOperation: {
         readonly 200: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
             data: z.ZodObject<{
                 readonly topic: z.ZodString;
+                readonly topicMetrics: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    _tag: z.ZodLiteral<"measured">;
+                    topic: z.ZodString;
+                    metrics: z.ZodObject<{
+                        readonly keyword: z.ZodString;
+                        readonly volume: z.ZodNullable<z.ZodNumber>;
+                        readonly difficulty: z.ZodNullable<z.ZodNumber>;
+                        readonly intent: z.ZodNullable<z.ZodString>;
+                        readonly secondaryIntents: z.ZodNullable<z.ZodArray<z.ZodString>>;
+                        readonly cpc: z.ZodNullable<z.ZodNumber>;
+                        readonly competition: z.ZodNullable<z.ZodNumber>;
+                        readonly competitionLevel: z.ZodNullable<z.ZodEnum<{
+                            HIGH: "HIGH";
+                            LOW: "LOW";
+                            MEDIUM: "MEDIUM";
+                        }>>;
+                        readonly lowBid: z.ZodNullable<z.ZodNumber>;
+                        readonly highBid: z.ZodNullable<z.ZodNumber>;
+                        readonly trend: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                            readonly year: z.ZodNumber;
+                            readonly month: z.ZodNumber;
+                            readonly volume: z.ZodNumber;
+                        }, z.core.$strip>>>;
+                        readonly serpFeatures: z.ZodNullable<z.ZodArray<z.ZodString>>;
+                        readonly backlinks: z.ZodNullable<z.ZodNumber>;
+                        readonly referringDomains: z.ZodNullable<z.ZodNumber>;
+                    }, z.core.$strip>;
+                }, z.core.$strict>, z.ZodObject<{
+                    _tag: z.ZodLiteral<"no-data">;
+                    topic: z.ZodString;
+                }, z.core.$strict>], "_tag">>;
                 readonly keywords: z.ZodArray<z.ZodObject<{
                     readonly keyword: z.ZodString;
                     readonly volume: z.ZodNullable<z.ZodNumber>;
@@ -1642,6 +1797,37 @@ export declare const keywordResearchOperation: {
         }, z.core.$strip>, z.ZodObject<{
             data: z.ZodObject<{
                 readonly topic: z.ZodString;
+                readonly topicMetrics: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    _tag: z.ZodLiteral<"measured">;
+                    topic: z.ZodString;
+                    metrics: z.ZodObject<{
+                        readonly keyword: z.ZodString;
+                        readonly volume: z.ZodNullable<z.ZodNumber>;
+                        readonly difficulty: z.ZodNullable<z.ZodNumber>;
+                        readonly intent: z.ZodNullable<z.ZodString>;
+                        readonly secondaryIntents: z.ZodNullable<z.ZodArray<z.ZodString>>;
+                        readonly cpc: z.ZodNullable<z.ZodNumber>;
+                        readonly competition: z.ZodNullable<z.ZodNumber>;
+                        readonly competitionLevel: z.ZodNullable<z.ZodEnum<{
+                            HIGH: "HIGH";
+                            LOW: "LOW";
+                            MEDIUM: "MEDIUM";
+                        }>>;
+                        readonly lowBid: z.ZodNullable<z.ZodNumber>;
+                        readonly highBid: z.ZodNullable<z.ZodNumber>;
+                        readonly trend: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                            readonly year: z.ZodNumber;
+                            readonly month: z.ZodNumber;
+                            readonly volume: z.ZodNumber;
+                        }, z.core.$strip>>>;
+                        readonly serpFeatures: z.ZodNullable<z.ZodArray<z.ZodString>>;
+                        readonly backlinks: z.ZodNullable<z.ZodNumber>;
+                        readonly referringDomains: z.ZodNullable<z.ZodNumber>;
+                    }, z.core.$strip>;
+                }, z.core.$loose>, z.ZodObject<{
+                    _tag: z.ZodLiteral<"no-data">;
+                    topic: z.ZodString;
+                }, z.core.$loose>], "_tag">>;
                 readonly keywords: z.ZodArray<z.ZodObject<{
                     readonly keyword: z.ZodString;
                     readonly volume: z.ZodNullable<z.ZodNumber>;
@@ -1803,7 +1989,7 @@ export declare const keywordResearchOperation: {
     };
     readonly docs: {
         readonly summary: 'Research keyword ideas';
-        readonly description: 'Returns keyword ideas with volume, difficulty, intent, cost data, and explicit provider execution and spend evidence. Local guidance and cached reads consume no units.';
+        readonly description: 'Returns exact metrics for each requested topic alongside filtered keyword ideas. Missing provider data stays explicit. Local guidance and cached reads consume no units.';
         readonly tags: readonly ["Research"];
         readonly examples: readonly [{
             readonly request: {
@@ -1820,6 +2006,10 @@ export declare const keywordResearchOperation: {
                 readonly body: {
                     readonly data: {
                         readonly topic: 'nuxt seo';
+                        readonly topicMetrics: readonly [{
+                            readonly _tag: 'no-data';
+                            readonly topic: 'nuxt seo';
+                        }];
                         readonly keywords: readonly [];
                         readonly totalFound: 0;
                         readonly filters: {
@@ -3122,117 +3312,1522 @@ export declare const domainAvailabilityOperation: {
         }];
     };
 };
-export declare const researchV1Registry: import("./core.js").PublicV1Registry<{
-    readonly overview: {
-        readonly id: 'research.overview';
-        readonly method: 'GET';
-        readonly path: '/api/v1/sites/{siteId}/research';
-        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 ["research:read"];
-            readonly minimumRole: 'viewer';
-            readonly ownership: 'site';
-        };
-        readonly request: {
-            readonly params: z.ZodObject<{
-                siteId: z.ZodString;
+export declare const competitorsListResponseSchema: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
+    data: z.ZodObject<{
+        readonly competitors: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            domain: z.ZodString;
+        }, z.core.$strict>>;
+    }, 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 competitors: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            domain: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strip>;
+    meta: z.ZodObject<{
+        requestId: z.ZodString;
+        version: z.ZodLiteral<"1.0">;
+    }, z.core.$loose>;
+}, z.core.$strip>>;
+export declare const competitorAddResponseSchema: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
+    data: z.ZodObject<{
+        readonly competitor: z.ZodObject<{
+            id: z.ZodString;
+            domain: z.ZodString;
+        }, z.core.$strict>;
+        readonly status: z.ZodLiteral<"queued">;
+    }, 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 competitor: z.ZodObject<{
+            id: z.ZodString;
+            domain: z.ZodString;
+        }, z.core.$strict>;
+        readonly status: z.ZodLiteral<"queued">;
+    }, z.core.$strip>;
+    meta: z.ZodObject<{
+        requestId: z.ZodString;
+        version: z.ZodLiteral<"1.0">;
+    }, z.core.$loose>;
+}, z.core.$strip>>;
+export declare const competitorRemoveResponseSchema: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
+    data: z.ZodObject<{
+        readonly competitorId: z.ZodString;
+        readonly deleted: z.ZodLiteral<true>;
+    }, 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 competitorId: z.ZodString;
+        readonly deleted: z.ZodLiteral<true>;
+    }, z.core.$strip>;
+    meta: z.ZodObject<{
+        requestId: z.ZodString;
+        version: z.ZodLiteral<"1.0">;
+    }, z.core.$loose>;
+}, z.core.$strip>>;
+export declare const competitorsListOperation: {
+    readonly id: 'research.competitors.list';
+    readonly method: 'GET';
+    readonly path: '/api/v1/sites/{siteId}/research/competitors';
+    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 ['research:read'];
+        readonly minimumRole: 'viewer';
+        readonly ownership: 'site';
+    };
+    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<{
+                readonly competitors: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    domain: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+                requestId: z.ZodString;
+                version: z.ZodLiteral<"1.0">;
             }, 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<{
-                    readonly evidence: z.ZodObject<{
-                        _tag: z.ZodLiteral<"stored">;
-                        provider: z.ZodLiteral<"dataforseo">;
-                        collectedAt: z.ZodNullable<z.ZodString>;
-                    }, z.core.$strict>;
-                    readonly summary: z.ZodObject<{
-                        competitorCount: z.ZodNumber;
-                        quickWins: z.ZodNumber;
-                        totalSharedKeywords: z.ZodNumber;
-                        totalTrafficValue: z.ZodNumber;
-                    }, z.core.$strict>;
-                    readonly subject: z.ZodNullable<z.ZodObject<{
-                        readonly domain: z.ZodString;
-                        readonly metrics: z.ZodObject<{
-                            readonly organicTraffic: z.ZodNullable<z.ZodNumber>;
-                            readonly totalKeywords: z.ZodNullable<z.ZodNumber>;
-                            readonly keywordFootprint: z.ZodNullable<z.ZodNumber>;
-                            readonly trafficValue: z.ZodNullable<z.ZodNumber>;
-                        }, z.core.$strip>;
-                        readonly history: z.ZodArray<z.ZodObject<{
-                            readonly observedAt: z.ZodNullable<z.ZodString>;
-                            readonly metrics: z.ZodObject<{
-                                readonly organicTraffic: z.ZodNullable<z.ZodNumber>;
-                                readonly totalKeywords: z.ZodNullable<z.ZodNumber>;
-                                readonly keywordFootprint: z.ZodNullable<z.ZodNumber>;
-                                readonly trafficValue: z.ZodNullable<z.ZodNumber>;
-                            }, z.core.$strip>;
-                        }, z.core.$strip>>;
-                        readonly collectedAt: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            data: z.ZodObject<{
+                readonly competitors: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    domain: z.ZodString;
+                }, z.core.$strict>>;
+            }, 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", "quota_exhausted", "provider_unavailable", "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.research';
+            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: 'List tracked competitors';
+        readonly description: 'Returns competitors you added to this Site. Suggested competitors stay excluded. Reads start no provider work.';
+        readonly tags: readonly ["Research"];
+        readonly examples: readonly [{
+            readonly request: {
+                readonly params: {
+                    readonly siteId: 's_example';
+                };
+            };
+            readonly response: {
+                readonly status: 200;
+                readonly body: {
+                    readonly data: {
+                        readonly competitors: readonly [{
+                            readonly id: 'c_example';
+                            readonly domain: 'rival.com';
+                        }];
+                    };
+                    readonly meta: {
+                        readonly requestId: 'req_example';
+                        readonly version: '1.0';
+                    };
+                };
+            };
+        }];
+    };
+};
+export declare const competitorAddOperation: {
+    readonly id: 'research.competitors.add';
+    readonly method: 'POST';
+    readonly path: '/api/v1/sites/{siteId}/research/competitors';
+    readonly visibility: 'public';
+    readonly semantics: {
+        readonly kind: 'mutation';
+        readonly sideEffects: 'state';
+        readonly retry: 'never';
+        readonly readConsistency: null;
+    };
+    readonly auth: {
+        readonly credentials: readonly ['session', 'api_token'];
+        readonly scopes: readonly ['research:write'];
+        readonly minimumRole: 'member';
+        readonly ownership: 'site';
+    };
+    readonly request: {
+        readonly params: z.ZodObject<{
+            siteId: z.ZodString;
+        }, z.core.$strict>;
+        readonly query: null;
+        readonly headers: null;
+        readonly body: z.ZodObject<{
+            domain: z.ZodString;
+        }, z.core.$strict>;
+    };
+    readonly responses: {
+        readonly 200: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
+            data: z.ZodObject<{
+                readonly competitor: z.ZodObject<{
+                    id: z.ZodString;
+                    domain: z.ZodString;
+                }, z.core.$strict>;
+                readonly status: z.ZodLiteral<"queued">;
+            }, 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 competitor: z.ZodObject<{
+                    id: z.ZodString;
+                    domain: z.ZodString;
+                }, z.core.$strict>;
+                readonly status: z.ZodLiteral<"queued">;
+            }, 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", "quota_exhausted", "provider_unavailable", "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.research';
+            readonly idFrom: 'params.siteId';
+        }];
+        readonly changes: readonly [{
+            readonly type: 'site.research';
+            readonly idFrom: 'params.siteId';
+        }];
+    };
+    readonly policy: {
+        readonly rate: {
+            readonly name: 'public-v1-fixed-window';
+            readonly limit: 50;
+            readonly windowSeconds: 60;
+        };
+        readonly idempotency: {
+            readonly _tag: 'none';
+        };
+        readonly entitlement: 'growth';
+        readonly meter: {
+            readonly key: 'dataforseo';
+            readonly units: 1;
+            readonly charge: 'always';
+        };
+    };
+    readonly lifecycle: {
+        readonly introduced: '1.2.0';
+    };
+    readonly docs: {
+        readonly summary: 'Add one tracked competitor';
+        readonly description: 'Queues analysis for one public domain you name. The existing Site and Team limits apply. Duplicate domains start no work.';
+        readonly tags: readonly ["Research"];
+        readonly examples: readonly [{
+            readonly request: {
+                readonly params: {
+                    readonly siteId: 's_example';
+                };
+                readonly body: {
+                    readonly domain: 'rival.com';
+                };
+            };
+            readonly response: {
+                readonly status: 200;
+                readonly body: {
+                    readonly data: {
+                        readonly competitor: {
+                            readonly id: 'c_example';
+                            readonly domain: 'rival.com';
+                        };
+                        readonly status: 'queued';
+                    };
+                    readonly meta: {
+                        readonly requestId: 'req_example';
+                        readonly version: '1.0';
+                    };
+                };
+            };
+        }];
+    };
+};
+export declare const competitorRemoveOperation: {
+    readonly id: 'research.competitors.remove';
+    readonly method: 'DELETE';
+    readonly path: '/api/v1/sites/{siteId}/research/competitors/{competitorId}';
+    readonly visibility: 'public';
+    readonly semantics: {
+        readonly kind: 'mutation';
+        readonly sideEffects: 'state';
+        readonly retry: 'never';
+        readonly readConsistency: null;
+    };
+    readonly auth: {
+        readonly credentials: readonly ['session', 'api_token'];
+        readonly scopes: readonly ['research:write'];
+        readonly minimumRole: 'member';
+        readonly ownership: 'site';
+    };
+    readonly request: {
+        readonly params: z.ZodObject<{
+            siteId: z.ZodString;
+            competitorId: 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<{
+                readonly competitorId: z.ZodString;
+                readonly deleted: z.ZodLiteral<true>;
+            }, 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 competitorId: z.ZodString;
+                readonly deleted: z.ZodLiteral<true>;
+            }, 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", "quota_exhausted", "provider_unavailable", "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.research';
+            readonly idFrom: 'params.siteId';
+        }];
+        readonly changes: readonly [{
+            readonly type: 'site.research';
+            readonly idFrom: 'params.siteId';
+        }];
+    };
+    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: 'Remove one tracked competitor';
+        readonly description: 'Removes a competitor from this Site using its listed id. Removal starts no provider work.';
+        readonly tags: readonly ["Research"];
+        readonly examples: readonly [{
+            readonly request: {
+                readonly params: {
+                    readonly siteId: 's_example';
+                    readonly competitorId: 'c_example';
+                };
+            };
+            readonly response: {
+                readonly status: 200;
+                readonly body: {
+                    readonly data: {
+                        readonly competitorId: 'c_example';
+                        readonly deleted: true;
+                    };
+                    readonly meta: {
+                        readonly requestId: 'req_example';
+                        readonly version: '1.0';
+                    };
+                };
+            };
+        }];
+    };
+};
+export declare const researchV1Registry: import("./core.js").PublicV1Registry<{
+    readonly overview: {
+        readonly id: 'research.overview';
+        readonly method: 'GET';
+        readonly path: '/api/v1/sites/{siteId}/research';
+        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 ["research:read"];
+            readonly minimumRole: 'viewer';
+            readonly ownership: 'site';
+        };
+        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<{
+                    readonly evidence: z.ZodObject<{
+                        _tag: z.ZodLiteral<"stored">;
+                        provider: z.ZodLiteral<"dataforseo">;
+                        collectedAt: z.ZodNullable<z.ZodString>;
+                    }, z.core.$strict>;
+                    readonly summary: z.ZodObject<{
+                        competitorCount: z.ZodNumber;
+                        quickWins: z.ZodNumber;
+                        totalSharedKeywords: z.ZodNumber;
+                        totalTrafficValue: z.ZodNumber;
+                    }, z.core.$strict>;
+                    readonly subject: z.ZodNullable<z.ZodObject<{
+                        readonly domain: z.ZodString;
+                        readonly metrics: z.ZodObject<{
+                            readonly organicTraffic: z.ZodNullable<z.ZodNumber>;
+                            readonly totalKeywords: z.ZodNullable<z.ZodNumber>;
+                            readonly keywordFootprint: z.ZodNullable<z.ZodNumber>;
+                            readonly trafficValue: z.ZodNullable<z.ZodNumber>;
+                        }, z.core.$strip>;
+                        readonly history: z.ZodArray<z.ZodObject<{
+                            readonly observedAt: z.ZodNullable<z.ZodString>;
+                            readonly metrics: z.ZodObject<{
+                                readonly organicTraffic: z.ZodNullable<z.ZodNumber>;
+                                readonly totalKeywords: z.ZodNullable<z.ZodNumber>;
+                                readonly keywordFootprint: z.ZodNullable<z.ZodNumber>;
+                                readonly trafficValue: z.ZodNullable<z.ZodNumber>;
+                            }, z.core.$strip>;
+                        }, z.core.$strip>>;
+                        readonly collectedAt: z.ZodNullable<z.ZodString>;
+                    }, z.core.$strip>>;
+                    readonly competitors: z.ZodArray<z.ZodObject<{
+                        readonly domain: z.ZodString;
+                        readonly discovery: z.ZodEnum<{
+                            automatic: "automatic";
+                            manual: "manual";
+                            unknown: "unknown";
+                        }>;
+                        readonly metrics: z.ZodObject<{
+                            readonly organicTraffic: z.ZodNullable<z.ZodNumber>;
+                            readonly totalKeywords: z.ZodNullable<z.ZodNumber>;
+                            readonly keywordFootprint: z.ZodNullable<z.ZodNumber>;
+                            readonly trafficValue: z.ZodNullable<z.ZodNumber>;
+                        }, z.core.$strip>;
+                        readonly topKeywords: z.ZodArray<z.ZodObject<{
+                            readonly keyword: z.ZodString;
+                            readonly position: z.ZodNullable<z.ZodNumber>;
+                            readonly volume: z.ZodNullable<z.ZodNumber>;
+                            readonly traffic: z.ZodNullable<z.ZodNumber>;
+                            readonly url: z.ZodNullable<z.ZodString>;
+                            readonly intent: z.ZodNullable<z.ZodString>;
+                        }, z.core.$strip>>;
+                        readonly sharedKeywords: z.ZodArray<z.ZodObject<{
+                            readonly keyword: z.ZodString;
+                            readonly yourPosition: z.ZodNumber;
+                            readonly theirPosition: z.ZodNumber;
+                            readonly volume: z.ZodNumber;
+                        }, z.core.$strip>>;
+                        readonly keywordGaps: z.ZodArray<z.ZodObject<{
+                            readonly keyword: z.ZodString;
+                            readonly position: z.ZodNullable<z.ZodNumber>;
+                            readonly volume: z.ZodNullable<z.ZodNumber>;
+                            readonly traffic: z.ZodNullable<z.ZodNumber>;
+                            readonly url: z.ZodNullable<z.ZodString>;
+                            readonly intent: z.ZodNullable<z.ZodString>;
+                        }, z.core.$strip>>;
+                        readonly quickWins: z.ZodArray<z.ZodObject<{
+                            readonly keyword: z.ZodString;
+                            readonly yourPosition: z.ZodNumber;
+                            readonly theirPosition: z.ZodNumber;
+                            readonly volume: z.ZodNumber;
+                        }, z.core.$strip>>;
+                        readonly history: z.ZodArray<z.ZodObject<{
+                            readonly observedAt: z.ZodNullable<z.ZodString>;
+                            readonly metrics: z.ZodObject<{
+                                readonly organicTraffic: z.ZodNullable<z.ZodNumber>;
+                                readonly totalKeywords: z.ZodNullable<z.ZodNumber>;
+                                readonly keywordFootprint: z.ZodNullable<z.ZodNumber>;
+                                readonly trafficValue: z.ZodNullable<z.ZodNumber>;
+                            }, z.core.$strip>;
+                        }, z.core.$strip>>;
+                        readonly collectedAt: z.ZodNullable<z.ZodString>;
+                    }, z.core.$strip>>;
+                }, 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 evidence: z.ZodObject<{
+                        _tag: z.ZodLiteral<"stored">;
+                        provider: z.ZodLiteral<"dataforseo">;
+                        collectedAt: z.ZodNullable<z.ZodString>;
+                    }, z.core.$loose>;
+                    readonly summary: z.ZodObject<{
+                        competitorCount: z.ZodNumber;
+                        quickWins: z.ZodNumber;
+                        totalSharedKeywords: z.ZodNumber;
+                        totalTrafficValue: z.ZodNumber;
+                    }, z.core.$loose>;
+                    readonly subject: z.ZodNullable<z.ZodObject<{
+                        readonly domain: z.ZodString;
+                        readonly metrics: z.ZodObject<{
+                            readonly organicTraffic: z.ZodNullable<z.ZodNumber>;
+                            readonly totalKeywords: z.ZodNullable<z.ZodNumber>;
+                            readonly keywordFootprint: z.ZodNullable<z.ZodNumber>;
+                            readonly trafficValue: z.ZodNullable<z.ZodNumber>;
+                        }, z.core.$strip>;
+                        readonly history: z.ZodArray<z.ZodObject<{
+                            readonly observedAt: z.ZodNullable<z.ZodString>;
+                            readonly metrics: z.ZodObject<{
+                                readonly organicTraffic: z.ZodNullable<z.ZodNumber>;
+                                readonly totalKeywords: z.ZodNullable<z.ZodNumber>;
+                                readonly keywordFootprint: z.ZodNullable<z.ZodNumber>;
+                                readonly trafficValue: z.ZodNullable<z.ZodNumber>;
+                            }, z.core.$strip>;
+                        }, z.core.$strip>>;
+                        readonly collectedAt: z.ZodNullable<z.ZodString>;
+                    }, z.core.$strip>>;
+                    readonly competitors: z.ZodArray<z.ZodObject<{
+                        readonly domain: z.ZodString;
+                        readonly discovery: z.ZodEnum<{
+                            automatic: "automatic";
+                            manual: "manual";
+                            unknown: "unknown";
+                        }>;
+                        readonly metrics: z.ZodObject<{
+                            readonly organicTraffic: z.ZodNullable<z.ZodNumber>;
+                            readonly totalKeywords: z.ZodNullable<z.ZodNumber>;
+                            readonly keywordFootprint: z.ZodNullable<z.ZodNumber>;
+                            readonly trafficValue: z.ZodNullable<z.ZodNumber>;
+                        }, z.core.$strip>;
+                        readonly topKeywords: z.ZodArray<z.ZodObject<{
+                            readonly keyword: z.ZodString;
+                            readonly position: z.ZodNullable<z.ZodNumber>;
+                            readonly volume: z.ZodNullable<z.ZodNumber>;
+                            readonly traffic: z.ZodNullable<z.ZodNumber>;
+                            readonly url: z.ZodNullable<z.ZodString>;
+                            readonly intent: z.ZodNullable<z.ZodString>;
+                        }, z.core.$strip>>;
+                        readonly sharedKeywords: z.ZodArray<z.ZodObject<{
+                            readonly keyword: z.ZodString;
+                            readonly yourPosition: z.ZodNumber;
+                            readonly theirPosition: z.ZodNumber;
+                            readonly volume: z.ZodNumber;
+                        }, z.core.$strip>>;
+                        readonly keywordGaps: z.ZodArray<z.ZodObject<{
+                            readonly keyword: z.ZodString;
+                            readonly position: z.ZodNullable<z.ZodNumber>;
+                            readonly volume: z.ZodNullable<z.ZodNumber>;
+                            readonly traffic: z.ZodNullable<z.ZodNumber>;
+                            readonly url: z.ZodNullable<z.ZodString>;
+                            readonly intent: z.ZodNullable<z.ZodString>;
+                        }, z.core.$strip>>;
+                        readonly quickWins: z.ZodArray<z.ZodObject<{
+                            readonly keyword: z.ZodString;
+                            readonly yourPosition: z.ZodNumber;
+                            readonly theirPosition: z.ZodNumber;
+                            readonly volume: z.ZodNumber;
+                        }, z.core.$strip>>;
+                        readonly history: z.ZodArray<z.ZodObject<{
+                            readonly observedAt: z.ZodNullable<z.ZodString>;
+                            readonly metrics: z.ZodObject<{
+                                readonly organicTraffic: z.ZodNullable<z.ZodNumber>;
+                                readonly totalKeywords: z.ZodNullable<z.ZodNumber>;
+                                readonly keywordFootprint: z.ZodNullable<z.ZodNumber>;
+                                readonly trafficValue: z.ZodNullable<z.ZodNumber>;
+                            }, z.core.$strip>;
+                        }, z.core.$strip>>;
+                        readonly collectedAt: z.ZodNullable<z.ZodString>;
+                    }, z.core.$strip>>;
+                }, 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", "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.research';
+                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.0.0';
+        };
+        readonly docs: {
+            readonly summary: 'Get stored Site Research';
+            readonly description: 'Returns retained competitor and keyword-gap evidence already collected for the Site. It never starts provider work and does not consume metered units.';
+            readonly tags: readonly ["Research"];
+            readonly examples: readonly [{
+                readonly request: {
+                    readonly params: {
+                        readonly siteId: 'site_01JXYZ';
+                    };
+                };
+                readonly response: {
+                    readonly status: 200;
+                    readonly body: {
+                        readonly data: {
+                            readonly evidence: {
+                                readonly _tag: 'stored';
+                                readonly provider: 'dataforseo';
+                                readonly collectedAt: null;
+                            };
+                            readonly summary: {
+                                readonly competitorCount: 0;
+                                readonly quickWins: 0;
+                                readonly totalSharedKeywords: 0;
+                                readonly totalTrafficValue: 0;
+                            };
+                            readonly subject: null;
+                            readonly competitors: readonly [];
+                        };
+                        readonly meta: {
+                            readonly requestId: 'req_01JXYZ';
+                            readonly version: '1.0';
+                        };
+                    };
+                };
+            }];
+        };
+    };
+    readonly keywords: {
+        readonly id: 'research.keywords';
+        readonly method: 'GET';
+        readonly path: '/api/v1/sites/{siteId}/research/keywords';
+        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 ['research:read'];
+            readonly minimumRole: 'viewer';
+            readonly ownership: 'site';
+        };
+        readonly request: {
+            readonly params: z.ZodObject<{
+                siteId: z.ZodString;
+            }, z.core.$strict>;
+            readonly query: z.ZodObject<{
+                topic: z.ZodString;
+                minVolume: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+                maxVolume: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+                minDifficulty: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+                maxDifficulty: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+                intent: z.ZodOptional<z.ZodString>;
+                includeRelated: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+                    0: "0";
+                    1: "1";
+                    false: "false";
+                    true: "true";
+                }>]>, z.ZodTransform<boolean, "0" | "1" | "false" | "true" | boolean>>>;
+                verbose: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+                    0: "0";
+                    1: "1";
+                    false: "false";
+                    true: "true";
+                }>]>, z.ZodTransform<boolean, "0" | "1" | "false" | "true" | boolean>>>;
+                limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+                locationCode: 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 topic: z.ZodString;
+                    readonly topicMetrics: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        _tag: z.ZodLiteral<"measured">;
+                        topic: z.ZodString;
+                        metrics: z.ZodObject<{
+                            readonly keyword: z.ZodString;
+                            readonly volume: z.ZodNullable<z.ZodNumber>;
+                            readonly difficulty: z.ZodNullable<z.ZodNumber>;
+                            readonly intent: z.ZodNullable<z.ZodString>;
+                            readonly secondaryIntents: z.ZodNullable<z.ZodArray<z.ZodString>>;
+                            readonly cpc: z.ZodNullable<z.ZodNumber>;
+                            readonly competition: z.ZodNullable<z.ZodNumber>;
+                            readonly competitionLevel: z.ZodNullable<z.ZodEnum<{
+                                HIGH: "HIGH";
+                                LOW: "LOW";
+                                MEDIUM: "MEDIUM";
+                            }>>;
+                            readonly lowBid: z.ZodNullable<z.ZodNumber>;
+                            readonly highBid: z.ZodNullable<z.ZodNumber>;
+                            readonly trend: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                                readonly year: z.ZodNumber;
+                                readonly month: z.ZodNumber;
+                                readonly volume: z.ZodNumber;
+                            }, z.core.$strip>>>;
+                            readonly serpFeatures: z.ZodNullable<z.ZodArray<z.ZodString>>;
+                            readonly backlinks: z.ZodNullable<z.ZodNumber>;
+                            readonly referringDomains: z.ZodNullable<z.ZodNumber>;
+                        }, z.core.$strip>;
+                    }, z.core.$strict>, z.ZodObject<{
+                        _tag: z.ZodLiteral<"no-data">;
+                        topic: z.ZodString;
+                    }, z.core.$strict>], "_tag">>;
+                    readonly keywords: z.ZodArray<z.ZodObject<{
+                        readonly keyword: z.ZodString;
+                        readonly volume: z.ZodNullable<z.ZodNumber>;
+                        readonly difficulty: z.ZodNullable<z.ZodNumber>;
+                        readonly intent: z.ZodNullable<z.ZodString>;
+                        readonly secondaryIntents: z.ZodNullable<z.ZodArray<z.ZodString>>;
+                        readonly cpc: z.ZodNullable<z.ZodNumber>;
+                        readonly competition: z.ZodNullable<z.ZodNumber>;
+                        readonly competitionLevel: z.ZodNullable<z.ZodEnum<{
+                            HIGH: "HIGH";
+                            LOW: "LOW";
+                            MEDIUM: "MEDIUM";
+                        }>>;
+                        readonly lowBid: z.ZodNullable<z.ZodNumber>;
+                        readonly highBid: z.ZodNullable<z.ZodNumber>;
+                        readonly trend: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                            readonly year: z.ZodNumber;
+                            readonly month: z.ZodNumber;
+                            readonly volume: z.ZodNumber;
+                        }, z.core.$strip>>>;
+                        readonly serpFeatures: z.ZodNullable<z.ZodArray<z.ZodString>>;
+                        readonly backlinks: z.ZodNullable<z.ZodNumber>;
+                        readonly referringDomains: z.ZodNullable<z.ZodNumber>;
+                    }, z.core.$strip>>;
+                    readonly totalFound: z.ZodNumber;
+                    readonly filters: z.ZodObject<{
+                        minVolume: z.ZodNumber;
+                        maxVolume: z.ZodNumber;
+                        minDifficulty: z.ZodNumber;
+                        maxDifficulty: z.ZodNumber;
+                        intent: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>;
+                    /**
+                     * Why a result set is empty, in one sentence for a person.
+                     *
+                     * The provider answers 200 with an empty list both when the argument was
+                     * refused and when the argument was accepted but matched nothing. `message`
+                     * is the only field that tells the two apart, so a caller that reads the list
+                     * alone will misread a refusal as an absence of demand. Present only when the
+                     * list is empty for a reason worth naming.
+                     */
+                    readonly message: z.ZodOptional<z.ZodString>;
+                    /**
+                     * A concrete next argument to try, when `message` names a fixable argument.
+                     */
+                    readonly tip: z.ZodOptional<z.ZodString>;
+                    readonly serpFallback: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                        message: z.ZodString;
+                        topResults: z.ZodArray<z.ZodObject<{
+                            readonly position: z.ZodNumber;
+                            readonly title: z.ZodString;
+                            readonly domain: z.ZodString;
+                            readonly url: z.ZodString;
+                        }, z.core.$strip>>;
+                        tip: z.ZodString;
+                    }, z.core.$strict>>>;
+                    readonly evidence: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        _tag: z.ZodLiteral<"no-provider">;
+                        provider: z.ZodNull;
+                        spend: z.ZodObject<{
+                            key: z.ZodLiteral<"dataforseo">;
+                            units: z.ZodLiteral<0>;
+                        }, z.core.$strict>;
+                    }, z.core.$strict>, z.ZodObject<{
+                        _tag: z.ZodLiteral<"cache">;
+                        provider: z.ZodLiteral<"dataforseo">;
+                        spend: z.ZodObject<{
+                            key: z.ZodLiteral<"dataforseo">;
+                            units: z.ZodLiteral<0>;
+                        }, z.core.$strict>;
+                    }, z.core.$strict>, z.ZodObject<{
+                        _tag: z.ZodLiteral<"live">;
+                        provider: z.ZodLiteral<"dataforseo">;
+                        spend: z.ZodObject<{
+                            key: z.ZodLiteral<"dataforseo">;
+                            units: z.ZodLiteral<1>;
+                        }, z.core.$strict>;
+                    }, z.core.$strict>], "_tag">;
+                }, 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 topic: z.ZodString;
+                    readonly topicMetrics: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        _tag: z.ZodLiteral<"measured">;
+                        topic: z.ZodString;
+                        metrics: z.ZodObject<{
+                            readonly keyword: z.ZodString;
+                            readonly volume: z.ZodNullable<z.ZodNumber>;
+                            readonly difficulty: z.ZodNullable<z.ZodNumber>;
+                            readonly intent: z.ZodNullable<z.ZodString>;
+                            readonly secondaryIntents: z.ZodNullable<z.ZodArray<z.ZodString>>;
+                            readonly cpc: z.ZodNullable<z.ZodNumber>;
+                            readonly competition: z.ZodNullable<z.ZodNumber>;
+                            readonly competitionLevel: z.ZodNullable<z.ZodEnum<{
+                                HIGH: "HIGH";
+                                LOW: "LOW";
+                                MEDIUM: "MEDIUM";
+                            }>>;
+                            readonly lowBid: z.ZodNullable<z.ZodNumber>;
+                            readonly highBid: z.ZodNullable<z.ZodNumber>;
+                            readonly trend: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                                readonly year: z.ZodNumber;
+                                readonly month: z.ZodNumber;
+                                readonly volume: z.ZodNumber;
+                            }, z.core.$strip>>>;
+                            readonly serpFeatures: z.ZodNullable<z.ZodArray<z.ZodString>>;
+                            readonly backlinks: z.ZodNullable<z.ZodNumber>;
+                            readonly referringDomains: z.ZodNullable<z.ZodNumber>;
+                        }, z.core.$strip>;
+                    }, z.core.$loose>, z.ZodObject<{
+                        _tag: z.ZodLiteral<"no-data">;
+                        topic: z.ZodString;
+                    }, z.core.$loose>], "_tag">>;
+                    readonly keywords: z.ZodArray<z.ZodObject<{
+                        readonly keyword: z.ZodString;
+                        readonly volume: z.ZodNullable<z.ZodNumber>;
+                        readonly difficulty: z.ZodNullable<z.ZodNumber>;
+                        readonly intent: z.ZodNullable<z.ZodString>;
+                        readonly secondaryIntents: z.ZodNullable<z.ZodArray<z.ZodString>>;
+                        readonly cpc: z.ZodNullable<z.ZodNumber>;
+                        readonly competition: z.ZodNullable<z.ZodNumber>;
+                        readonly competitionLevel: z.ZodNullable<z.ZodEnum<{
+                            HIGH: "HIGH";
+                            LOW: "LOW";
+                            MEDIUM: "MEDIUM";
+                        }>>;
+                        readonly lowBid: z.ZodNullable<z.ZodNumber>;
+                        readonly highBid: z.ZodNullable<z.ZodNumber>;
+                        readonly trend: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                            readonly year: z.ZodNumber;
+                            readonly month: z.ZodNumber;
+                            readonly volume: z.ZodNumber;
+                        }, z.core.$strip>>>;
+                        readonly serpFeatures: z.ZodNullable<z.ZodArray<z.ZodString>>;
+                        readonly backlinks: z.ZodNullable<z.ZodNumber>;
+                        readonly referringDomains: z.ZodNullable<z.ZodNumber>;
+                    }, z.core.$strip>>;
+                    readonly totalFound: z.ZodNumber;
+                    readonly filters: z.ZodObject<{
+                        minVolume: z.ZodNumber;
+                        maxVolume: z.ZodNumber;
+                        minDifficulty: z.ZodNumber;
+                        maxDifficulty: z.ZodNumber;
+                        intent: z.ZodOptional<z.ZodString>;
+                    }, z.core.$loose>;
+                    /**
+                     * Why a result set is empty, in one sentence for a person.
+                     *
+                     * The provider answers 200 with an empty list both when the argument was
+                     * refused and when the argument was accepted but matched nothing. `message`
+                     * is the only field that tells the two apart, so a caller that reads the list
+                     * alone will misread a refusal as an absence of demand. Present only when the
+                     * list is empty for a reason worth naming.
+                     */
+                    readonly message: z.ZodOptional<z.ZodString>;
+                    /**
+                     * A concrete next argument to try, when `message` names a fixable argument.
+                     */
+                    readonly tip: z.ZodOptional<z.ZodString>;
+                    readonly serpFallback: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                        message: z.ZodString;
+                        topResults: z.ZodArray<z.ZodObject<{
+                            readonly position: z.ZodNumber;
+                            readonly title: z.ZodString;
+                            readonly domain: z.ZodString;
+                            readonly url: z.ZodString;
+                        }, z.core.$strip>>;
+                        tip: z.ZodString;
+                    }, z.core.$loose>>>;
+                    readonly evidence: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        _tag: z.ZodLiteral<"no-provider">;
+                        provider: z.ZodNull;
+                        spend: z.ZodObject<{
+                            key: z.ZodLiteral<"dataforseo">;
+                            units: z.ZodLiteral<0>;
+                        }, z.core.$loose>;
+                    }, z.core.$loose>, z.ZodObject<{
+                        _tag: z.ZodLiteral<"cache">;
+                        provider: z.ZodLiteral<"dataforseo">;
+                        spend: z.ZodObject<{
+                            key: z.ZodLiteral<"dataforseo">;
+                            units: z.ZodLiteral<0>;
+                        }, z.core.$loose>;
+                    }, z.core.$loose>, z.ZodObject<{
+                        _tag: z.ZodLiteral<"live">;
+                        provider: z.ZodLiteral<"dataforseo">;
+                        spend: z.ZodObject<{
+                            key: z.ZodLiteral<"dataforseo">;
+                            units: z.ZodLiteral<1>;
+                        }, z.core.$loose>;
+                    }, z.core.$loose>], "_tag">;
+                }, 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", "quota_exhausted", "provider_unavailable", "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.research';
+                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: 'growth';
+            readonly meter: {
+                readonly key: 'dataforseo';
+                readonly units: 1;
+                readonly charge: 'live-only';
+            };
+        };
+        readonly lifecycle: {
+            readonly introduced: '1.0.0';
+        };
+        readonly docs: {
+            readonly summary: 'Research keyword ideas';
+            readonly description: 'Returns exact metrics for each requested topic alongside filtered keyword ideas. Missing provider data stays explicit. Local guidance and cached reads consume no units.';
+            readonly tags: readonly ["Research"];
+            readonly examples: readonly [{
+                readonly request: {
+                    readonly params: {
+                        readonly siteId: 'site_01JXYZ';
+                    };
+                    readonly query: {
+                        readonly topic: 'nuxt seo';
+                        readonly limit: 20;
+                    };
+                };
+                readonly response: {
+                    readonly status: 200;
+                    readonly body: {
+                        readonly data: {
+                            readonly topic: 'nuxt seo';
+                            readonly topicMetrics: readonly [{
+                                readonly _tag: 'no-data';
+                                readonly topic: 'nuxt seo';
+                            }];
+                            readonly keywords: readonly [];
+                            readonly totalFound: 0;
+                            readonly filters: {
+                                readonly minVolume: 10;
+                                readonly maxVolume: 10000;
+                                readonly minDifficulty: 0;
+                                readonly maxDifficulty: 60;
+                            };
+                            readonly evidence: {
+                                readonly _tag: 'live';
+                                readonly provider: 'dataforseo';
+                                readonly spend: {
+                                    readonly key: 'dataforseo';
+                                    readonly units: 1;
+                                };
+                            };
+                        };
+                        readonly meta: {
+                            readonly requestId: 'req_01JXYZ';
+                            readonly version: '1.0';
+                        };
+                    };
+                };
+            }];
+        };
+    };
+    readonly serp: {
+        readonly id: 'research.serp';
+        readonly method: 'GET';
+        readonly path: '/api/v1/sites/{siteId}/research/serp';
+        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 ['research:read'];
+            readonly minimumRole: 'viewer';
+            readonly ownership: 'site';
+        };
+        readonly request: {
+            readonly params: z.ZodObject<{
+                siteId: z.ZodString;
+            }, z.core.$strict>;
+            readonly query: z.ZodObject<{
+                keyword: z.ZodString;
+                depth: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+                locationCode: 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 keyword: z.ZodString;
+                    readonly depth: z.ZodNumber;
+                    readonly results: z.ZodArray<z.ZodObject<{
+                        readonly position: z.ZodNumber;
+                        readonly url: z.ZodString;
+                        readonly title: z.ZodString;
+                        readonly domain: z.ZodString;
+                        readonly description: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    readonly serpFeatures: z.ZodArray<z.ZodString>;
+                    readonly hasAiOverview: z.ZodBoolean;
+                    readonly hasFeaturedSnippet: z.ZodBoolean;
+                    readonly hasLocalPack: z.ZodBoolean;
+                    readonly hasPeopleAlsoAsk: z.ZodBoolean;
+                    readonly fetchedAt: z.ZodString;
+                    readonly cached: z.ZodBoolean;
+                }, 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 keyword: z.ZodString;
+                    readonly depth: z.ZodNumber;
+                    readonly results: z.ZodArray<z.ZodObject<{
+                        readonly position: z.ZodNumber;
+                        readonly url: z.ZodString;
+                        readonly title: z.ZodString;
+                        readonly domain: z.ZodString;
+                        readonly description: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    readonly serpFeatures: z.ZodArray<z.ZodString>;
+                    readonly hasAiOverview: z.ZodBoolean;
+                    readonly hasFeaturedSnippet: z.ZodBoolean;
+                    readonly hasLocalPack: z.ZodBoolean;
+                    readonly hasPeopleAlsoAsk: z.ZodBoolean;
+                    readonly fetchedAt: z.ZodString;
+                    readonly cached: z.ZodBoolean;
+                }, 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", "quota_exhausted", "provider_unavailable", "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.research';
+                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: 'growth';
+            readonly meter: {
+                readonly key: 'dataforseo';
+                readonly units: 1;
+                readonly charge: 'live-only';
+            };
+        };
+        readonly lifecycle: {
+            readonly introduced: '1.0.0';
+        };
+        readonly docs: {
+            readonly summary: 'Analyze a Google SERP';
+            readonly description: 'Returns one dated SERP snapshot and its result features. Cached reads consume no units.';
+            readonly tags: readonly ["Research"];
+            readonly examples: readonly [{
+                readonly request: {
+                    readonly params: {
+                        readonly siteId: 'site_01JXYZ';
+                    };
+                    readonly query: {
+                        readonly keyword: 'nuxt seo';
+                        readonly depth: 10;
+                    };
+                };
+                readonly response: {
+                    readonly status: 200;
+                    readonly body: {
+                        readonly data: {
+                            readonly keyword: 'nuxt seo';
+                            readonly depth: 10;
+                            readonly results: readonly [];
+                            readonly serpFeatures: readonly [];
+                            readonly hasAiOverview: false;
+                            readonly hasFeaturedSnippet: false;
+                            readonly hasLocalPack: false;
+                            readonly hasPeopleAlsoAsk: false;
+                            readonly fetchedAt: '2026-08-20T00:00:00.000Z';
+                            readonly cached: false;
+                        };
+                        readonly meta: {
+                            readonly requestId: 'req_01JXYZ';
+                            readonly version: '1.0';
+                        };
+                    };
+                };
+            }];
+        };
+    };
+    readonly rankings: {
+        readonly id: 'research.rankings';
+        readonly method: 'GET';
+        readonly path: '/api/v1/sites/{siteId}/research/rankings';
+        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 ['research:read'];
+            readonly minimumRole: 'viewer';
+            readonly ownership: 'site';
+        };
+        readonly request: {
+            readonly params: z.ZodObject<{
+                siteId: z.ZodString;
+            }, z.core.$strict>;
+            readonly query: z.ZodObject<{
+                domain: z.ZodString;
+                limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+                minPosition: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+                maxPosition: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+                locationCode: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+                order: z.ZodDefault<z.ZodEnum<{
+                    position: "position";
+                    traffic: "traffic";
+                }>>;
+            }, z.core.$strict>;
+            readonly headers: null;
+            readonly body: null;
+        };
+        readonly responses: {
+            readonly 200: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
+                data: z.ZodObject<{
+                    readonly domain: z.ZodString;
+                    readonly keywords: z.ZodArray<z.ZodObject<{
+                        readonly keyword: z.ZodString;
+                        readonly position: z.ZodNumber;
+                        readonly volume: z.ZodNumber;
+                        readonly traffic: z.ZodNumber;
+                        readonly url: z.ZodString;
+                        readonly intent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                     }, z.core.$strip>>;
-                    readonly competitors: z.ZodArray<z.ZodObject<{
-                        readonly domain: z.ZodString;
-                        readonly discovery: z.ZodEnum<{
-                            automatic: "automatic";
-                            manual: "manual";
-                            unknown: "unknown";
-                        }>;
-                        readonly metrics: z.ZodObject<{
-                            readonly organicTraffic: z.ZodNullable<z.ZodNumber>;
-                            readonly totalKeywords: z.ZodNullable<z.ZodNumber>;
-                            readonly keywordFootprint: z.ZodNullable<z.ZodNumber>;
-                            readonly trafficValue: z.ZodNullable<z.ZodNumber>;
-                        }, z.core.$strip>;
-                        readonly topKeywords: z.ZodArray<z.ZodObject<{
-                            readonly keyword: z.ZodString;
-                            readonly position: z.ZodNullable<z.ZodNumber>;
-                            readonly volume: z.ZodNullable<z.ZodNumber>;
-                            readonly traffic: z.ZodNullable<z.ZodNumber>;
-                            readonly url: z.ZodNullable<z.ZodString>;
-                            readonly intent: z.ZodNullable<z.ZodString>;
-                        }, z.core.$strip>>;
-                        readonly sharedKeywords: z.ZodArray<z.ZodObject<{
-                            readonly keyword: z.ZodString;
-                            readonly yourPosition: z.ZodNumber;
-                            readonly theirPosition: z.ZodNumber;
-                            readonly volume: z.ZodNumber;
-                        }, z.core.$strip>>;
-                        readonly keywordGaps: z.ZodArray<z.ZodObject<{
-                            readonly keyword: z.ZodString;
-                            readonly position: z.ZodNullable<z.ZodNumber>;
-                            readonly volume: z.ZodNullable<z.ZodNumber>;
-                            readonly traffic: z.ZodNullable<z.ZodNumber>;
-                            readonly url: z.ZodNullable<z.ZodString>;
-                            readonly intent: z.ZodNullable<z.ZodString>;
-                        }, z.core.$strip>>;
-                        readonly quickWins: z.ZodArray<z.ZodObject<{
-                            readonly keyword: z.ZodString;
-                            readonly yourPosition: z.ZodNumber;
-                            readonly theirPosition: z.ZodNumber;
-                            readonly volume: z.ZodNumber;
-                        }, z.core.$strip>>;
-                        readonly history: z.ZodArray<z.ZodObject<{
-                            readonly observedAt: z.ZodNullable<z.ZodString>;
-                            readonly metrics: z.ZodObject<{
-                                readonly organicTraffic: z.ZodNullable<z.ZodNumber>;
-                                readonly totalKeywords: z.ZodNullable<z.ZodNumber>;
-                                readonly keywordFootprint: z.ZodNullable<z.ZodNumber>;
-                                readonly trafficValue: z.ZodNullable<z.ZodNumber>;
-                            }, z.core.$strip>;
+                    readonly totalFound: z.ZodNumber;
+                    readonly metrics: z.ZodNullable<z.ZodObject<{
+                        readonly organicTraffic: z.ZodNumber;
+                        readonly totalKeywords: z.ZodNumber;
+                        readonly keywordFootprint: z.ZodObject<{
+                            score: z.ZodNullable<z.ZodNumber>;
+                            scale: z.ZodObject<{
+                                min: z.ZodLiteral<0>;
+                                max: z.ZodLiteral<100>;
+                            }, z.core.$strict>;
+                            provenance: z.ZodLiteral<"local-keyword-count">;
+                        }, z.core.$strict>;
+                        readonly trafficValue: z.ZodNullable<z.ZodNumber>;
+                        readonly topPages: z.ZodArray<z.ZodObject<{
+                            readonly path: z.ZodString;
+                            readonly traffic: z.ZodNumber;
+                            readonly keywords: z.ZodNumber;
                         }, z.core.$strip>>;
-                        readonly collectedAt: z.ZodNullable<z.ZodString>;
                     }, z.core.$strip>>;
+                    readonly positionRange: z.ZodOptional<z.ZodObject<{
+                        min: z.ZodNumber;
+                        max: z.ZodNumber;
+                    }, z.core.$strict>>;
+                    /**
+                     * Why a result set is empty, in one sentence for a person.
+                     *
+                     * The provider answers 200 with an empty list both when the argument was
+                     * refused and when the argument was accepted but matched nothing. `message`
+                     * is the only field that tells the two apart, so a caller that reads the list
+                     * alone will misread a refusal as an absence of demand. Present only when the
+                     * list is empty for a reason worth naming.
+                     */
+                    readonly message: z.ZodOptional<z.ZodString>;
+                    readonly cached: z.ZodBoolean;
                 }, z.core.$strip>;
                 meta: z.ZodObject<{
                     requestId: z.ZodString;
@@ -3240,88 +4835,49 @@ export declare const researchV1Registry: import("./core.js").PublicV1Registry<{
                 }, z.core.$strict>;
             }, z.core.$strip>, z.ZodObject<{
                 data: z.ZodObject<{
-                    readonly evidence: z.ZodObject<{
-                        _tag: z.ZodLiteral<"stored">;
-                        provider: z.ZodLiteral<"dataforseo">;
-                        collectedAt: z.ZodNullable<z.ZodString>;
-                    }, z.core.$loose>;
-                    readonly summary: z.ZodObject<{
-                        competitorCount: z.ZodNumber;
-                        quickWins: z.ZodNumber;
-                        totalSharedKeywords: z.ZodNumber;
-                        totalTrafficValue: z.ZodNumber;
-                    }, z.core.$loose>;
-                    readonly subject: z.ZodNullable<z.ZodObject<{
-                        readonly domain: z.ZodString;
-                        readonly metrics: z.ZodObject<{
-                            readonly organicTraffic: z.ZodNullable<z.ZodNumber>;
-                            readonly totalKeywords: z.ZodNullable<z.ZodNumber>;
-                            readonly keywordFootprint: z.ZodNullable<z.ZodNumber>;
-                            readonly trafficValue: z.ZodNullable<z.ZodNumber>;
-                        }, z.core.$strip>;
-                        readonly history: z.ZodArray<z.ZodObject<{
-                            readonly observedAt: z.ZodNullable<z.ZodString>;
-                            readonly metrics: z.ZodObject<{
-                                readonly organicTraffic: z.ZodNullable<z.ZodNumber>;
-                                readonly totalKeywords: z.ZodNullable<z.ZodNumber>;
-                                readonly keywordFootprint: z.ZodNullable<z.ZodNumber>;
-                                readonly trafficValue: z.ZodNullable<z.ZodNumber>;
-                            }, z.core.$strip>;
-                        }, z.core.$strip>>;
-                        readonly collectedAt: z.ZodNullable<z.ZodString>;
+                    readonly domain: z.ZodString;
+                    readonly keywords: z.ZodArray<z.ZodObject<{
+                        readonly keyword: z.ZodString;
+                        readonly position: z.ZodNumber;
+                        readonly volume: z.ZodNumber;
+                        readonly traffic: z.ZodNumber;
+                        readonly url: z.ZodString;
+                        readonly intent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                     }, z.core.$strip>>;
-                    readonly competitors: z.ZodArray<z.ZodObject<{
-                        readonly domain: z.ZodString;
-                        readonly discovery: z.ZodEnum<{
-                            automatic: "automatic";
-                            manual: "manual";
-                            unknown: "unknown";
-                        }>;
-                        readonly metrics: z.ZodObject<{
-                            readonly organicTraffic: z.ZodNullable<z.ZodNumber>;
-                            readonly totalKeywords: z.ZodNullable<z.ZodNumber>;
-                            readonly keywordFootprint: z.ZodNullable<z.ZodNumber>;
-                            readonly trafficValue: z.ZodNullable<z.ZodNumber>;
-                        }, z.core.$strip>;
-                        readonly topKeywords: z.ZodArray<z.ZodObject<{
-                            readonly keyword: z.ZodString;
-                            readonly position: z.ZodNullable<z.ZodNumber>;
-                            readonly volume: z.ZodNullable<z.ZodNumber>;
-                            readonly traffic: z.ZodNullable<z.ZodNumber>;
-                            readonly url: z.ZodNullable<z.ZodString>;
-                            readonly intent: z.ZodNullable<z.ZodString>;
-                        }, z.core.$strip>>;
-                        readonly sharedKeywords: z.ZodArray<z.ZodObject<{
-                            readonly keyword: z.ZodString;
-                            readonly yourPosition: z.ZodNumber;
-                            readonly theirPosition: z.ZodNumber;
-                            readonly volume: z.ZodNumber;
-                        }, z.core.$strip>>;
-                        readonly keywordGaps: z.ZodArray<z.ZodObject<{
-                            readonly keyword: z.ZodString;
-                            readonly position: z.ZodNullable<z.ZodNumber>;
-                            readonly volume: z.ZodNullable<z.ZodNumber>;
-                            readonly traffic: z.ZodNullable<z.ZodNumber>;
-                            readonly url: z.ZodNullable<z.ZodString>;
-                            readonly intent: z.ZodNullable<z.ZodString>;
-                        }, z.core.$strip>>;
-                        readonly quickWins: z.ZodArray<z.ZodObject<{
-                            readonly keyword: z.ZodString;
-                            readonly yourPosition: z.ZodNumber;
-                            readonly theirPosition: z.ZodNumber;
-                            readonly volume: z.ZodNumber;
-                        }, z.core.$strip>>;
-                        readonly history: z.ZodArray<z.ZodObject<{
-                            readonly observedAt: z.ZodNullable<z.ZodString>;
-                            readonly metrics: z.ZodObject<{
-                                readonly organicTraffic: z.ZodNullable<z.ZodNumber>;
-                                readonly totalKeywords: z.ZodNullable<z.ZodNumber>;
-                                readonly keywordFootprint: z.ZodNullable<z.ZodNumber>;
-                                readonly trafficValue: z.ZodNullable<z.ZodNumber>;
-                            }, z.core.$strip>;
+                    readonly totalFound: z.ZodNumber;
+                    readonly metrics: z.ZodNullable<z.ZodObject<{
+                        readonly organicTraffic: z.ZodNumber;
+                        readonly totalKeywords: z.ZodNumber;
+                        readonly keywordFootprint: z.ZodObject<{
+                            score: z.ZodNullable<z.ZodNumber>;
+                            scale: z.ZodObject<{
+                                min: z.ZodLiteral<0>;
+                                max: z.ZodLiteral<100>;
+                            }, z.core.$loose>;
+                            provenance: z.ZodLiteral<"local-keyword-count">;
+                        }, z.core.$loose>;
+                        readonly trafficValue: z.ZodNullable<z.ZodNumber>;
+                        readonly topPages: z.ZodArray<z.ZodObject<{
+                            readonly path: z.ZodString;
+                            readonly traffic: z.ZodNumber;
+                            readonly keywords: z.ZodNumber;
                         }, z.core.$strip>>;
-                        readonly collectedAt: z.ZodNullable<z.ZodString>;
                     }, z.core.$strip>>;
+                    readonly positionRange: z.ZodOptional<z.ZodObject<{
+                        min: z.ZodNumber;
+                        max: z.ZodNumber;
+                    }, z.core.$loose>>;
+                    /**
+                     * Why a result set is empty, in one sentence for a person.
+                     *
+                     * The provider answers 200 with an empty list both when the argument was
+                     * refused and when the argument was accepted but matched nothing. `message`
+                     * is the only field that tells the two apart, so a caller that reads the list
+                     * alone will misread a refusal as an absence of demand. Present only when the
+                     * list is empty for a reason worth naming.
+                     */
+                    readonly message: z.ZodOptional<z.ZodString>;
+                    readonly cached: z.ZodBoolean;
                 }, z.core.$strip>;
                 meta: z.ZodObject<{
                     requestId: z.ZodString;
@@ -3329,7 +4885,7 @@ export declare const researchV1Registry: import("./core.js").PublicV1Registry<{
                 }, z.core.$loose>;
             }, z.core.$strip>>;
         };
-        readonly errors: readonly ["invalid_request", "unauthorized", "auth_expired", "forbidden", "not_found", "conflict", "rate_limited", "contract_violation", "internal_error"];
+        readonly errors: readonly ["invalid_request", "unauthorized", "auth_expired", "forbidden", "not_found", "entitlement_required", "quota_exhausted", "provider_unavailable", "conflict", "rate_limited", "contract_violation", "internal_error"];
         readonly errorResponse: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
             readonly error: z.ZodObject<{
                 code: z.ZodEnum<{
@@ -3393,39 +4949,43 @@ export declare const researchV1Registry: import("./core.js").PublicV1Registry<{
             readonly idempotency: {
                 readonly _tag: 'none';
             };
-            readonly entitlement: null;
-            readonly meter: null;
+            readonly entitlement: 'growth';
+            readonly meter: {
+                readonly key: 'dataforseo';
+                readonly units: 1;
+                readonly charge: 'live-only';
+            };
         };
         readonly lifecycle: {
             readonly introduced: '1.0.0';
         };
         readonly docs: {
-            readonly summary: 'Get stored Site Research';
-            readonly description: 'Returns retained competitor and keyword-gap evidence already collected for the Site. It never starts provider work and does not consume metered units.';
+            readonly summary: 'Research domain rankings';
+            readonly description: 'Returns current keyword rankings and domain metrics. Cached reads consume no units.';
             readonly tags: readonly ["Research"];
             readonly examples: readonly [{
                 readonly request: {
                     readonly params: {
                         readonly siteId: 'site_01JXYZ';
                     };
+                    readonly query: {
+                        readonly domain: 'nuxtseo.com';
+                        readonly limit: 20;
+                    };
                 };
                 readonly response: {
                     readonly status: 200;
                     readonly body: {
                         readonly data: {
-                            readonly evidence: {
-                                readonly _tag: 'stored';
-                                readonly provider: 'dataforseo';
-                                readonly collectedAt: null;
-                            };
-                            readonly summary: {
-                                readonly competitorCount: 0;
-                                readonly quickWins: 0;
-                                readonly totalSharedKeywords: 0;
-                                readonly totalTrafficValue: 0;
+                            readonly domain: 'nuxtseo.com';
+                            readonly keywords: readonly [];
+                            readonly totalFound: 0;
+                            readonly metrics: null;
+                            readonly positionRange: {
+                                readonly min: 1;
+                                readonly max: 20;
                             };
-                            readonly subject: null;
-                            readonly competitors: readonly [];
+                            readonly cached: false;
                         };
                         readonly meta: {
                             readonly requestId: 'req_01JXYZ';
@@ -3436,10 +4996,10 @@ export declare const researchV1Registry: import("./core.js").PublicV1Registry<{
             }];
         };
     };
-    readonly keywords: {
-        readonly id: 'research.keywords';
+    readonly domainTraffic: {
+        readonly id: 'research.domain.traffic';
         readonly method: 'GET';
-        readonly path: '/api/v1/sites/{siteId}/research/keywords';
+        readonly path: '/api/v1/sites/{siteId}/research/domain-traffic';
         readonly visibility: 'public';
         readonly semantics: {
             readonly kind: 'query';
@@ -3458,26 +5018,7 @@ export declare const researchV1Registry: import("./core.js").PublicV1Registry<{
                 siteId: z.ZodString;
             }, z.core.$strict>;
             readonly query: z.ZodObject<{
-                topic: z.ZodString;
-                minVolume: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-                maxVolume: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-                minDifficulty: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-                maxDifficulty: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-                intent: z.ZodOptional<z.ZodString>;
-                includeRelated: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-                    0: "0";
-                    1: "1";
-                    false: "false";
-                    true: "true";
-                }>]>, z.ZodTransform<boolean, "0" | "1" | "false" | "true" | boolean>>>;
-                verbose: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-                    0: "0";
-                    1: "1";
-                    false: "false";
-                    true: "true";
-                }>]>, z.ZodTransform<boolean, "0" | "1" | "false" | "true" | boolean>>>;
-                limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-                locationCode: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+                domain: z.ZodString;
             }, z.core.$strict>;
             readonly headers: null;
             readonly body: null;
@@ -3485,63 +5026,26 @@ export declare const researchV1Registry: import("./core.js").PublicV1Registry<{
         readonly responses: {
             readonly 200: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
                 data: z.ZodObject<{
-                    readonly topic: z.ZodString;
-                    readonly keywords: z.ZodArray<z.ZodObject<{
-                        readonly keyword: z.ZodString;
-                        readonly volume: z.ZodNullable<z.ZodNumber>;
-                        readonly difficulty: z.ZodNullable<z.ZodNumber>;
-                        readonly intent: z.ZodNullable<z.ZodString>;
-                        readonly secondaryIntents: z.ZodNullable<z.ZodArray<z.ZodString>>;
-                        readonly cpc: z.ZodNullable<z.ZodNumber>;
-                        readonly competition: z.ZodNullable<z.ZodNumber>;
-                        readonly competitionLevel: z.ZodNullable<z.ZodEnum<{
-                            HIGH: "HIGH";
-                            LOW: "LOW";
-                            MEDIUM: "MEDIUM";
-                        }>>;
-                        readonly lowBid: z.ZodNullable<z.ZodNumber>;
-                        readonly highBid: z.ZodNullable<z.ZodNumber>;
-                        readonly trend: z.ZodNullable<z.ZodArray<z.ZodObject<{
-                            readonly year: z.ZodNumber;
-                            readonly month: z.ZodNumber;
-                            readonly volume: z.ZodNumber;
-                        }, z.core.$strip>>>;
-                        readonly serpFeatures: z.ZodNullable<z.ZodArray<z.ZodString>>;
-                        readonly backlinks: z.ZodNullable<z.ZodNumber>;
-                        readonly referringDomains: z.ZodNullable<z.ZodNumber>;
+                    readonly domain: z.ZodString;
+                    readonly monthlyTraffic: z.ZodNumber;
+                    readonly trend: z.ZodEnum<{
+                        declining: "declining";
+                        growing: "growing";
+                        stable: "stable";
+                    }>;
+                    readonly changePercent: z.ZodNumber;
+                    readonly trafficValue: z.ZodNullable<z.ZodNumber>;
+                    readonly keywordFootprint: z.ZodNullable<z.ZodNumber>;
+                    readonly topPages: z.ZodArray<z.ZodObject<{
+                        readonly path: z.ZodString;
+                        readonly traffic: z.ZodNumber;
+                        readonly keywords: z.ZodNumber;
                     }, z.core.$strip>>;
-                    readonly totalFound: z.ZodNumber;
-                    readonly filters: z.ZodObject<{
-                        minVolume: z.ZodNumber;
-                        maxVolume: z.ZodNumber;
-                        minDifficulty: z.ZodNumber;
-                        maxDifficulty: z.ZodNumber;
-                        intent: z.ZodOptional<z.ZodString>;
-                    }, z.core.$strict>;
-                    /**
-                     * Why a result set is empty, in one sentence for a person.
-                     *
-                     * The provider answers 200 with an empty list both when the argument was
-                     * refused and when the argument was accepted but matched nothing. `message`
-                     * is the only field that tells the two apart, so a caller that reads the list
-                     * alone will misread a refusal as an absence of demand. Present only when the
-                     * list is empty for a reason worth naming.
-                     */
-                    readonly message: z.ZodOptional<z.ZodString>;
-                    /**
-                     * A concrete next argument to try, when `message` names a fixable argument.
-                     */
-                    readonly tip: z.ZodOptional<z.ZodString>;
-                    readonly serpFallback: z.ZodOptional<z.ZodNullable<z.ZodObject<{
-                        message: z.ZodString;
-                        topResults: z.ZodArray<z.ZodObject<{
-                            readonly position: z.ZodNumber;
-                            readonly title: z.ZodString;
-                            readonly domain: z.ZodString;
-                            readonly url: z.ZodString;
-                        }, z.core.$strip>>;
-                        tip: z.ZodString;
-                    }, z.core.$strict>>>;
+                    readonly topCountries: z.ZodArray<z.ZodObject<{
+                        country: z.ZodString;
+                        percent: z.ZodNumber;
+                    }, z.core.$strict>>;
+                    readonly message: z.ZodNullable<z.ZodString>;
                     readonly evidence: z.ZodDiscriminatedUnion<[z.ZodObject<{
                         _tag: z.ZodLiteral<"no-provider">;
                         provider: z.ZodNull;
@@ -3571,63 +5075,26 @@ export declare const researchV1Registry: import("./core.js").PublicV1Registry<{
                 }, z.core.$strict>;
             }, z.core.$strip>, z.ZodObject<{
                 data: z.ZodObject<{
-                    readonly topic: z.ZodString;
-                    readonly keywords: z.ZodArray<z.ZodObject<{
-                        readonly keyword: z.ZodString;
-                        readonly volume: z.ZodNullable<z.ZodNumber>;
-                        readonly difficulty: z.ZodNullable<z.ZodNumber>;
-                        readonly intent: z.ZodNullable<z.ZodString>;
-                        readonly secondaryIntents: z.ZodNullable<z.ZodArray<z.ZodString>>;
-                        readonly cpc: z.ZodNullable<z.ZodNumber>;
-                        readonly competition: z.ZodNullable<z.ZodNumber>;
-                        readonly competitionLevel: z.ZodNullable<z.ZodEnum<{
-                            HIGH: "HIGH";
-                            LOW: "LOW";
-                            MEDIUM: "MEDIUM";
-                        }>>;
-                        readonly lowBid: z.ZodNullable<z.ZodNumber>;
-                        readonly highBid: z.ZodNullable<z.ZodNumber>;
-                        readonly trend: z.ZodNullable<z.ZodArray<z.ZodObject<{
-                            readonly year: z.ZodNumber;
-                            readonly month: z.ZodNumber;
-                            readonly volume: z.ZodNumber;
-                        }, z.core.$strip>>>;
-                        readonly serpFeatures: z.ZodNullable<z.ZodArray<z.ZodString>>;
-                        readonly backlinks: z.ZodNullable<z.ZodNumber>;
-                        readonly referringDomains: z.ZodNullable<z.ZodNumber>;
+                    readonly domain: z.ZodString;
+                    readonly monthlyTraffic: z.ZodNumber;
+                    readonly trend: z.ZodEnum<{
+                        declining: "declining";
+                        growing: "growing";
+                        stable: "stable";
+                    }>;
+                    readonly changePercent: z.ZodNumber;
+                    readonly trafficValue: z.ZodNullable<z.ZodNumber>;
+                    readonly keywordFootprint: z.ZodNullable<z.ZodNumber>;
+                    readonly topPages: z.ZodArray<z.ZodObject<{
+                        readonly path: z.ZodString;
+                        readonly traffic: z.ZodNumber;
+                        readonly keywords: z.ZodNumber;
                     }, z.core.$strip>>;
-                    readonly totalFound: z.ZodNumber;
-                    readonly filters: z.ZodObject<{
-                        minVolume: z.ZodNumber;
-                        maxVolume: z.ZodNumber;
-                        minDifficulty: z.ZodNumber;
-                        maxDifficulty: z.ZodNumber;
-                        intent: z.ZodOptional<z.ZodString>;
-                    }, z.core.$loose>;
-                    /**
-                     * Why a result set is empty, in one sentence for a person.
-                     *
-                     * The provider answers 200 with an empty list both when the argument was
-                     * refused and when the argument was accepted but matched nothing. `message`
-                     * is the only field that tells the two apart, so a caller that reads the list
-                     * alone will misread a refusal as an absence of demand. Present only when the
-                     * list is empty for a reason worth naming.
-                     */
-                    readonly message: z.ZodOptional<z.ZodString>;
-                    /**
-                     * A concrete next argument to try, when `message` names a fixable argument.
-                     */
-                    readonly tip: z.ZodOptional<z.ZodString>;
-                    readonly serpFallback: z.ZodOptional<z.ZodNullable<z.ZodObject<{
-                        message: z.ZodString;
-                        topResults: z.ZodArray<z.ZodObject<{
-                            readonly position: z.ZodNumber;
-                            readonly title: z.ZodString;
-                            readonly domain: z.ZodString;
-                            readonly url: z.ZodString;
-                        }, z.core.$strip>>;
-                        tip: z.ZodString;
-                    }, z.core.$loose>>>;
+                    readonly topCountries: z.ZodArray<z.ZodObject<{
+                        country: z.ZodString;
+                        percent: z.ZodNumber;
+                    }, z.core.$loose>>;
+                    readonly message: z.ZodNullable<z.ZodString>;
                     readonly evidence: z.ZodDiscriminatedUnion<[z.ZodObject<{
                         _tag: z.ZodLiteral<"no-provider">;
                         provider: z.ZodNull;
@@ -3729,11 +5196,11 @@ export declare const researchV1Registry: import("./core.js").PublicV1Registry<{
             };
         };
         readonly lifecycle: {
-            readonly introduced: '1.0.0';
+            readonly introduced: '1.2.0';
         };
         readonly docs: {
-            readonly summary: 'Research keyword ideas';
-            readonly description: 'Returns keyword ideas with volume, difficulty, intent, cost data, and explicit provider execution and spend evidence. Local guidance and cached reads consume no units.';
+            readonly summary: 'Estimate domain traffic';
+            readonly description: 'Returns an estimate of one domain organic search traffic, its trend, its top pages and countries. The domain does not have to be one of your Sites, so this reads a competitor as readily as your own. Cached reads consume no units.';
             readonly tags: readonly ["Research"];
             readonly examples: readonly [{
                 readonly request: {
@@ -3741,23 +5208,29 @@ export declare const researchV1Registry: import("./core.js").PublicV1Registry<{
                         readonly siteId: 'site_01JXYZ';
                     };
                     readonly query: {
-                        readonly topic: 'nuxt seo';
-                        readonly limit: 20;
+                        readonly domain: 'nuxtseo.com';
                     };
                 };
                 readonly response: {
                     readonly status: 200;
                     readonly body: {
                         readonly data: {
-                            readonly topic: 'nuxt seo';
-                            readonly keywords: readonly [];
-                            readonly totalFound: 0;
-                            readonly filters: {
-                                readonly minVolume: 10;
-                                readonly maxVolume: 10000;
-                                readonly minDifficulty: 0;
-                                readonly maxDifficulty: 60;
-                            };
+                            readonly domain: 'nuxtseo.com';
+                            readonly monthlyTraffic: 48200;
+                            readonly trend: 'growing';
+                            readonly changePercent: 12.4;
+                            readonly trafficValue: 31200;
+                            readonly keywordFootprint: 62;
+                            readonly topPages: readonly [{
+                                readonly path: '/docs/sitemap';
+                                readonly traffic: 4100;
+                                readonly keywords: 220;
+                            }];
+                            readonly topCountries: readonly [{
+                                readonly country: 'US';
+                                readonly percent: 41.2;
+                            }];
+                            readonly message: null;
                             readonly evidence: {
                                 readonly _tag: 'live';
                                 readonly provider: 'dataforseo';
@@ -3776,10 +5249,10 @@ export declare const researchV1Registry: import("./core.js").PublicV1Registry<{
             }];
         };
     };
-    readonly serp: {
-        readonly id: 'research.serp';
+    readonly domainAvailability: {
+        readonly id: 'research.domain.availability';
         readonly method: 'GET';
-        readonly path: '/api/v1/sites/{siteId}/research/serp';
+        readonly path: '/api/v1/sites/{siteId}/research/domain-availability';
         readonly visibility: 'public';
         readonly semantics: {
             readonly kind: 'query';
@@ -3797,33 +5270,46 @@ export declare const researchV1Registry: import("./core.js").PublicV1Registry<{
             readonly params: z.ZodObject<{
                 siteId: z.ZodString;
             }, z.core.$strict>;
-            readonly query: z.ZodObject<{
-                keyword: z.ZodString;
-                depth: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-                locationCode: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-            }, z.core.$strict>;
+            readonly query: z.ZodObject<{
+                domains: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodPipe<z.ZodString, z.ZodTransform<string[], string>>]>;
+            }, z.core.$strict>;
             readonly headers: null;
             readonly body: null;
         };
         readonly responses: {
             readonly 200: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
                 data: z.ZodObject<{
-                    readonly keyword: z.ZodString;
-                    readonly depth: z.ZodNumber;
                     readonly results: z.ZodArray<z.ZodObject<{
-                        readonly position: z.ZodNumber;
-                        readonly url: z.ZodString;
-                        readonly title: z.ZodString;
                         readonly domain: z.ZodString;
-                        readonly description: z.ZodOptional<z.ZodString>;
+                        readonly available: z.ZodBoolean;
+                        readonly registrar: z.ZodNullable<z.ZodString>;
+                        readonly expiration: z.ZodNullable<z.ZodString>;
+                        readonly created: z.ZodNullable<z.ZodString>;
+                        readonly note: z.ZodNullable<z.ZodString>;
                     }, z.core.$strip>>;
-                    readonly serpFeatures: z.ZodArray<z.ZodString>;
-                    readonly hasAiOverview: z.ZodBoolean;
-                    readonly hasFeaturedSnippet: z.ZodBoolean;
-                    readonly hasLocalPack: z.ZodBoolean;
-                    readonly hasPeopleAlsoAsk: z.ZodBoolean;
-                    readonly fetchedAt: z.ZodString;
-                    readonly cached: z.ZodBoolean;
+                    readonly message: z.ZodNullable<z.ZodString>;
+                    readonly evidence: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        _tag: z.ZodLiteral<"no-provider">;
+                        provider: z.ZodNull;
+                        spend: z.ZodObject<{
+                            key: z.ZodLiteral<"dataforseo">;
+                            units: z.ZodLiteral<0>;
+                        }, z.core.$strict>;
+                    }, z.core.$strict>, z.ZodObject<{
+                        _tag: z.ZodLiteral<"cache">;
+                        provider: z.ZodLiteral<"dataforseo">;
+                        spend: z.ZodObject<{
+                            key: z.ZodLiteral<"dataforseo">;
+                            units: z.ZodLiteral<0>;
+                        }, z.core.$strict>;
+                    }, z.core.$strict>, z.ZodObject<{
+                        _tag: z.ZodLiteral<"live">;
+                        provider: z.ZodLiteral<"dataforseo">;
+                        spend: z.ZodObject<{
+                            key: z.ZodLiteral<"dataforseo">;
+                            units: z.ZodLiteral<1>;
+                        }, z.core.$strict>;
+                    }, z.core.$strict>], "_tag">;
                 }, z.core.$strip>;
                 meta: z.ZodObject<{
                     requestId: z.ZodString;
@@ -3831,22 +5317,37 @@ export declare const researchV1Registry: import("./core.js").PublicV1Registry<{
                 }, z.core.$strict>;
             }, z.core.$strip>, z.ZodObject<{
                 data: z.ZodObject<{
-                    readonly keyword: z.ZodString;
-                    readonly depth: z.ZodNumber;
                     readonly results: z.ZodArray<z.ZodObject<{
-                        readonly position: z.ZodNumber;
-                        readonly url: z.ZodString;
-                        readonly title: z.ZodString;
                         readonly domain: z.ZodString;
-                        readonly description: z.ZodOptional<z.ZodString>;
+                        readonly available: z.ZodBoolean;
+                        readonly registrar: z.ZodNullable<z.ZodString>;
+                        readonly expiration: z.ZodNullable<z.ZodString>;
+                        readonly created: z.ZodNullable<z.ZodString>;
+                        readonly note: z.ZodNullable<z.ZodString>;
                     }, z.core.$strip>>;
-                    readonly serpFeatures: z.ZodArray<z.ZodString>;
-                    readonly hasAiOverview: z.ZodBoolean;
-                    readonly hasFeaturedSnippet: z.ZodBoolean;
-                    readonly hasLocalPack: z.ZodBoolean;
-                    readonly hasPeopleAlsoAsk: z.ZodBoolean;
-                    readonly fetchedAt: z.ZodString;
-                    readonly cached: z.ZodBoolean;
+                    readonly message: z.ZodNullable<z.ZodString>;
+                    readonly evidence: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        _tag: z.ZodLiteral<"no-provider">;
+                        provider: z.ZodNull;
+                        spend: z.ZodObject<{
+                            key: z.ZodLiteral<"dataforseo">;
+                            units: z.ZodLiteral<0>;
+                        }, z.core.$loose>;
+                    }, z.core.$loose>, z.ZodObject<{
+                        _tag: z.ZodLiteral<"cache">;
+                        provider: z.ZodLiteral<"dataforseo">;
+                        spend: z.ZodObject<{
+                            key: z.ZodLiteral<"dataforseo">;
+                            units: z.ZodLiteral<0>;
+                        }, z.core.$loose>;
+                    }, z.core.$loose>, z.ZodObject<{
+                        _tag: z.ZodLiteral<"live">;
+                        provider: z.ZodLiteral<"dataforseo">;
+                        spend: z.ZodObject<{
+                            key: z.ZodLiteral<"dataforseo">;
+                            units: z.ZodLiteral<1>;
+                        }, z.core.$loose>;
+                    }, z.core.$loose>], "_tag">;
                 }, z.core.$strip>;
                 meta: z.ZodObject<{
                     requestId: z.ZodString;
@@ -3926,11 +5427,11 @@ export declare const researchV1Registry: import("./core.js").PublicV1Registry<{
             };
         };
         readonly lifecycle: {
-            readonly introduced: '1.0.0';
+            readonly introduced: '1.2.0';
         };
         readonly docs: {
-            readonly summary: 'Analyze a Google SERP';
-            readonly description: 'Returns one dated SERP snapshot and its result features. Cached reads consume no units.';
+            readonly summary: 'Check domain availability';
+            readonly description: 'Returns the registration status of up to ten domains, with the registrar and expiry when the domain is taken. Repeat the domains parameter for each domain. Cached reads consume no units.';
             readonly tags: readonly ["Research"];
             readonly examples: readonly [{
                 readonly request: {
@@ -3938,24 +5439,30 @@ export declare const researchV1Registry: import("./core.js").PublicV1Registry<{
                         readonly siteId: 'site_01JXYZ';
                     };
                     readonly query: {
-                        readonly keyword: 'nuxt seo';
-                        readonly depth: 10;
+                        readonly domains: readonly ["example.com", "example.dev"];
                     };
                 };
                 readonly response: {
                     readonly status: 200;
                     readonly body: {
                         readonly data: {
-                            readonly keyword: 'nuxt seo';
-                            readonly depth: 10;
-                            readonly results: readonly [];
-                            readonly serpFeatures: readonly [];
-                            readonly hasAiOverview: false;
-                            readonly hasFeaturedSnippet: false;
-                            readonly hasLocalPack: false;
-                            readonly hasPeopleAlsoAsk: false;
-                            readonly fetchedAt: '2026-08-20T00:00:00.000Z';
-                            readonly cached: false;
+                            readonly results: readonly [{
+                                readonly domain: 'example.com';
+                                readonly available: false;
+                                readonly registrar: 'Example Registrar';
+                                readonly expiration: '2027-04-01';
+                                readonly created: '1995-08-14';
+                                readonly note: null;
+                            }];
+                            readonly message: null;
+                            readonly evidence: {
+                                readonly _tag: 'live';
+                                readonly provider: 'dataforseo';
+                                readonly spend: {
+                                    readonly key: 'dataforseo';
+                                    readonly units: 1;
+                                };
+                            };
                         };
                         readonly meta: {
                             readonly requestId: 'req_01JXYZ';
@@ -3966,10 +5473,10 @@ export declare const researchV1Registry: import("./core.js").PublicV1Registry<{
             }];
         };
     };
-    readonly rankings: {
-        readonly id: 'research.rankings';
+    readonly listCompetitors: {
+        readonly id: 'research.competitors.list';
         readonly method: 'GET';
-        readonly path: '/api/v1/sites/{siteId}/research/rankings';
+        readonly path: '/api/v1/sites/{siteId}/research/competitors';
         readonly visibility: 'public';
         readonly semantics: {
             readonly kind: 'query';
@@ -3987,66 +5494,17 @@ export declare const researchV1Registry: import("./core.js").PublicV1Registry<{
             readonly params: z.ZodObject<{
                 siteId: z.ZodString;
             }, z.core.$strict>;
-            readonly query: z.ZodObject<{
-                domain: z.ZodString;
-                limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-                minPosition: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-                maxPosition: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-                locationCode: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-                order: z.ZodDefault<z.ZodEnum<{
-                    position: "position";
-                    traffic: "traffic";
-                }>>;
-            }, 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<{
-                    readonly domain: z.ZodString;
-                    readonly keywords: z.ZodArray<z.ZodObject<{
-                        readonly keyword: z.ZodString;
-                        readonly position: z.ZodNumber;
-                        readonly volume: z.ZodNumber;
-                        readonly traffic: z.ZodNumber;
-                        readonly url: z.ZodString;
-                        readonly intent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                    }, z.core.$strip>>;
-                    readonly totalFound: z.ZodNumber;
-                    readonly metrics: z.ZodNullable<z.ZodObject<{
-                        readonly organicTraffic: z.ZodNumber;
-                        readonly totalKeywords: z.ZodNumber;
-                        readonly keywordFootprint: z.ZodObject<{
-                            score: z.ZodNullable<z.ZodNumber>;
-                            scale: z.ZodObject<{
-                                min: z.ZodLiteral<0>;
-                                max: z.ZodLiteral<100>;
-                            }, z.core.$strict>;
-                            provenance: z.ZodLiteral<"local-keyword-count">;
-                        }, z.core.$strict>;
-                        readonly trafficValue: z.ZodNullable<z.ZodNumber>;
-                        readonly topPages: z.ZodArray<z.ZodObject<{
-                            readonly path: z.ZodString;
-                            readonly traffic: z.ZodNumber;
-                            readonly keywords: z.ZodNumber;
-                        }, z.core.$strip>>;
-                    }, z.core.$strip>>;
-                    readonly positionRange: z.ZodOptional<z.ZodObject<{
-                        min: z.ZodNumber;
-                        max: z.ZodNumber;
+                    readonly competitors: z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        domain: z.ZodString;
                     }, z.core.$strict>>;
-                    /**
-                     * Why a result set is empty, in one sentence for a person.
-                     *
-                     * The provider answers 200 with an empty list both when the argument was
-                     * refused and when the argument was accepted but matched nothing. `message`
-                     * is the only field that tells the two apart, so a caller that reads the list
-                     * alone will misread a refusal as an absence of demand. Present only when the
-                     * list is empty for a reason worth naming.
-                     */
-                    readonly message: z.ZodOptional<z.ZodString>;
-                    readonly cached: z.ZodBoolean;
                 }, z.core.$strip>;
                 meta: z.ZodObject<{
                     requestId: z.ZodString;
@@ -4054,49 +5512,10 @@ export declare const researchV1Registry: import("./core.js").PublicV1Registry<{
                 }, z.core.$strict>;
             }, z.core.$strip>, z.ZodObject<{
                 data: z.ZodObject<{
-                    readonly domain: z.ZodString;
-                    readonly keywords: z.ZodArray<z.ZodObject<{
-                        readonly keyword: z.ZodString;
-                        readonly position: z.ZodNumber;
-                        readonly volume: z.ZodNumber;
-                        readonly traffic: z.ZodNumber;
-                        readonly url: z.ZodString;
-                        readonly intent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                    }, z.core.$strip>>;
-                    readonly totalFound: z.ZodNumber;
-                    readonly metrics: z.ZodNullable<z.ZodObject<{
-                        readonly organicTraffic: z.ZodNumber;
-                        readonly totalKeywords: z.ZodNumber;
-                        readonly keywordFootprint: z.ZodObject<{
-                            score: z.ZodNullable<z.ZodNumber>;
-                            scale: z.ZodObject<{
-                                min: z.ZodLiteral<0>;
-                                max: z.ZodLiteral<100>;
-                            }, z.core.$loose>;
-                            provenance: z.ZodLiteral<"local-keyword-count">;
-                        }, z.core.$loose>;
-                        readonly trafficValue: z.ZodNullable<z.ZodNumber>;
-                        readonly topPages: z.ZodArray<z.ZodObject<{
-                            readonly path: z.ZodString;
-                            readonly traffic: z.ZodNumber;
-                            readonly keywords: z.ZodNumber;
-                        }, z.core.$strip>>;
-                    }, z.core.$strip>>;
-                    readonly positionRange: z.ZodOptional<z.ZodObject<{
-                        min: z.ZodNumber;
-                        max: z.ZodNumber;
-                    }, z.core.$loose>>;
-                    /**
-                     * Why a result set is empty, in one sentence for a person.
-                     *
-                     * The provider answers 200 with an empty list both when the argument was
-                     * refused and when the argument was accepted but matched nothing. `message`
-                     * is the only field that tells the two apart, so a caller that reads the list
-                     * alone will misread a refusal as an absence of demand. Present only when the
-                     * list is empty for a reason worth naming.
-                     */
-                    readonly message: z.ZodOptional<z.ZodString>;
-                    readonly cached: z.ZodBoolean;
+                    readonly competitors: z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        domain: z.ZodString;
+                    }, z.core.$strict>>;
                 }, z.core.$strip>;
                 meta: z.ZodObject<{
                     requestId: z.ZodString;
@@ -4168,46 +5587,33 @@ export declare const researchV1Registry: import("./core.js").PublicV1Registry<{
             readonly idempotency: {
                 readonly _tag: 'none';
             };
-            readonly entitlement: 'growth';
-            readonly meter: {
-                readonly key: 'dataforseo';
-                readonly units: 1;
-                readonly charge: 'live-only';
-            };
+            readonly entitlement: null;
+            readonly meter: null;
         };
         readonly lifecycle: {
-            readonly introduced: '1.0.0';
+            readonly introduced: '1.2.0';
         };
         readonly docs: {
-            readonly summary: 'Research domain rankings';
-            readonly description: 'Returns current keyword rankings and domain metrics. Cached reads consume no units.';
+            readonly summary: 'List tracked competitors';
+            readonly description: 'Returns competitors you added to this Site. Suggested competitors stay excluded. Reads start no provider work.';
             readonly tags: readonly ["Research"];
             readonly examples: readonly [{
                 readonly request: {
                     readonly params: {
-                        readonly siteId: 'site_01JXYZ';
-                    };
-                    readonly query: {
-                        readonly domain: 'nuxtseo.com';
-                        readonly limit: 20;
-                    };
-                };
-                readonly response: {
-                    readonly status: 200;
-                    readonly body: {
-                        readonly data: {
-                            readonly domain: 'nuxtseo.com';
-                            readonly keywords: readonly [];
-                            readonly totalFound: 0;
-                            readonly metrics: null;
-                            readonly positionRange: {
-                                readonly min: 1;
-                                readonly max: 20;
-                            };
-                            readonly cached: false;
+                        readonly siteId: 's_example';
+                    };
+                };
+                readonly response: {
+                    readonly status: 200;
+                    readonly body: {
+                        readonly data: {
+                            readonly competitors: readonly [{
+                                readonly id: 'c_example';
+                                readonly domain: 'rival.com';
+                            }];
                         };
                         readonly meta: {
-                            readonly requestId: 'req_01JXYZ';
+                            readonly requestId: 'req_example';
                             readonly version: '1.0';
                         };
                     };
@@ -4215,78 +5621,41 @@ export declare const researchV1Registry: import("./core.js").PublicV1Registry<{
             }];
         };
     };
-    readonly domainTraffic: {
-        readonly id: 'research.domain.traffic';
-        readonly method: 'GET';
-        readonly path: '/api/v1/sites/{siteId}/research/domain-traffic';
+    readonly addCompetitor: {
+        readonly id: 'research.competitors.add';
+        readonly method: 'POST';
+        readonly path: '/api/v1/sites/{siteId}/research/competitors';
         readonly visibility: 'public';
         readonly semantics: {
-            readonly kind: 'query';
-            readonly sideEffects: 'none';
-            readonly retry: 'idempotent';
-            readonly readConsistency: 'primary';
+            readonly kind: 'mutation';
+            readonly sideEffects: 'state';
+            readonly retry: 'never';
+            readonly readConsistency: null;
         };
         readonly auth: {
             readonly credentials: readonly ['session', 'api_token'];
-            readonly scopes: readonly ['research:read'];
-            readonly minimumRole: 'viewer';
+            readonly scopes: readonly ['research:write'];
+            readonly minimumRole: 'member';
             readonly ownership: 'site';
         };
         readonly request: {
             readonly params: z.ZodObject<{
                 siteId: z.ZodString;
             }, z.core.$strict>;
-            readonly query: z.ZodObject<{
+            readonly query: null;
+            readonly headers: null;
+            readonly body: z.ZodObject<{
                 domain: z.ZodString;
             }, z.core.$strict>;
-            readonly headers: null;
-            readonly body: null;
         };
         readonly responses: {
             readonly 200: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
                 data: z.ZodObject<{
-                    readonly domain: z.ZodString;
-                    readonly monthlyTraffic: z.ZodNumber;
-                    readonly trend: z.ZodEnum<{
-                        declining: "declining";
-                        growing: "growing";
-                        stable: "stable";
-                    }>;
-                    readonly changePercent: z.ZodNumber;
-                    readonly trafficValue: z.ZodNullable<z.ZodNumber>;
-                    readonly keywordFootprint: z.ZodNullable<z.ZodNumber>;
-                    readonly topPages: z.ZodArray<z.ZodObject<{
-                        readonly path: z.ZodString;
-                        readonly traffic: z.ZodNumber;
-                        readonly keywords: z.ZodNumber;
-                    }, z.core.$strip>>;
-                    readonly topCountries: z.ZodArray<z.ZodObject<{
-                        country: z.ZodString;
-                        percent: z.ZodNumber;
-                    }, z.core.$strict>>;
-                    readonly message: z.ZodNullable<z.ZodString>;
-                    readonly evidence: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                        _tag: z.ZodLiteral<"no-provider">;
-                        provider: z.ZodNull;
-                        spend: z.ZodObject<{
-                            key: z.ZodLiteral<"dataforseo">;
-                            units: z.ZodLiteral<0>;
-                        }, z.core.$strict>;
-                    }, z.core.$strict>, z.ZodObject<{
-                        _tag: z.ZodLiteral<"cache">;
-                        provider: z.ZodLiteral<"dataforseo">;
-                        spend: z.ZodObject<{
-                            key: z.ZodLiteral<"dataforseo">;
-                            units: z.ZodLiteral<0>;
-                        }, z.core.$strict>;
-                    }, z.core.$strict>, z.ZodObject<{
-                        _tag: z.ZodLiteral<"live">;
-                        provider: z.ZodLiteral<"dataforseo">;
-                        spend: z.ZodObject<{
-                            key: z.ZodLiteral<"dataforseo">;
-                            units: z.ZodLiteral<1>;
-                        }, z.core.$strict>;
-                    }, z.core.$strict>], "_tag">;
+                    readonly competitor: z.ZodObject<{
+                        id: z.ZodString;
+                        domain: z.ZodString;
+                    }, z.core.$strict>;
+                    readonly status: z.ZodLiteral<"queued">;
                 }, z.core.$strip>;
                 meta: z.ZodObject<{
                     requestId: z.ZodString;
@@ -4294,48 +5663,11 @@ export declare const researchV1Registry: import("./core.js").PublicV1Registry<{
                 }, z.core.$strict>;
             }, z.core.$strip>, z.ZodObject<{
                 data: z.ZodObject<{
-                    readonly domain: z.ZodString;
-                    readonly monthlyTraffic: z.ZodNumber;
-                    readonly trend: z.ZodEnum<{
-                        declining: "declining";
-                        growing: "growing";
-                        stable: "stable";
-                    }>;
-                    readonly changePercent: z.ZodNumber;
-                    readonly trafficValue: z.ZodNullable<z.ZodNumber>;
-                    readonly keywordFootprint: z.ZodNullable<z.ZodNumber>;
-                    readonly topPages: z.ZodArray<z.ZodObject<{
-                        readonly path: z.ZodString;
-                        readonly traffic: z.ZodNumber;
-                        readonly keywords: z.ZodNumber;
-                    }, z.core.$strip>>;
-                    readonly topCountries: z.ZodArray<z.ZodObject<{
-                        country: z.ZodString;
-                        percent: z.ZodNumber;
-                    }, z.core.$loose>>;
-                    readonly message: z.ZodNullable<z.ZodString>;
-                    readonly evidence: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                        _tag: z.ZodLiteral<"no-provider">;
-                        provider: z.ZodNull;
-                        spend: z.ZodObject<{
-                            key: z.ZodLiteral<"dataforseo">;
-                            units: z.ZodLiteral<0>;
-                        }, z.core.$loose>;
-                    }, z.core.$loose>, z.ZodObject<{
-                        _tag: z.ZodLiteral<"cache">;
-                        provider: z.ZodLiteral<"dataforseo">;
-                        spend: z.ZodObject<{
-                            key: z.ZodLiteral<"dataforseo">;
-                            units: z.ZodLiteral<0>;
-                        }, z.core.$loose>;
-                    }, z.core.$loose>, z.ZodObject<{
-                        _tag: z.ZodLiteral<"live">;
-                        provider: z.ZodLiteral<"dataforseo">;
-                        spend: z.ZodObject<{
-                            key: z.ZodLiteral<"dataforseo">;
-                            units: z.ZodLiteral<1>;
-                        }, z.core.$loose>;
-                    }, z.core.$loose>], "_tag">;
+                    readonly competitor: z.ZodObject<{
+                        id: z.ZodString;
+                        domain: z.ZodString;
+                    }, z.core.$strict>;
+                    readonly status: z.ZodLiteral<"queued">;
                 }, z.core.$strip>;
                 meta: z.ZodObject<{
                     requestId: z.ZodString;
@@ -4396,7 +5728,10 @@ export declare const researchV1Registry: import("./core.js").PublicV1Registry<{
                 readonly type: 'site.research';
                 readonly idFrom: 'params.siteId';
             }];
-            readonly changes: readonly [];
+            readonly changes: readonly [{
+                readonly type: 'site.research';
+                readonly idFrom: 'params.siteId';
+            }];
         };
         readonly policy: {
             readonly rate: {
@@ -4411,56 +5746,37 @@ export declare const researchV1Registry: import("./core.js").PublicV1Registry<{
             readonly meter: {
                 readonly key: 'dataforseo';
                 readonly units: 1;
-                readonly charge: 'live-only';
+                readonly charge: 'always';
             };
         };
         readonly lifecycle: {
             readonly introduced: '1.2.0';
         };
         readonly docs: {
-            readonly summary: 'Estimate domain traffic';
-            readonly description: 'Returns an estimate of one domain organic search traffic, its trend, its top pages and countries. The domain does not have to be one of your Sites, so this reads a competitor as readily as your own. Cached reads consume no units.';
+            readonly summary: 'Add one tracked competitor';
+            readonly description: 'Queues analysis for one public domain you name. The existing Site and Team limits apply. Duplicate domains start no work.';
             readonly tags: readonly ["Research"];
             readonly examples: readonly [{
                 readonly request: {
                     readonly params: {
-                        readonly siteId: 'site_01JXYZ';
+                        readonly siteId: 's_example';
                     };
-                    readonly query: {
-                        readonly domain: 'nuxtseo.com';
+                    readonly body: {
+                        readonly domain: 'rival.com';
                     };
                 };
                 readonly response: {
                     readonly status: 200;
                     readonly body: {
                         readonly data: {
-                            readonly domain: 'nuxtseo.com';
-                            readonly monthlyTraffic: 48200;
-                            readonly trend: 'growing';
-                            readonly changePercent: 12.4;
-                            readonly trafficValue: 31200;
-                            readonly keywordFootprint: 62;
-                            readonly topPages: readonly [{
-                                readonly path: '/docs/sitemap';
-                                readonly traffic: 4100;
-                                readonly keywords: 220;
-                            }];
-                            readonly topCountries: readonly [{
-                                readonly country: 'US';
-                                readonly percent: 41.2;
-                            }];
-                            readonly message: null;
-                            readonly evidence: {
-                                readonly _tag: 'live';
-                                readonly provider: 'dataforseo';
-                                readonly spend: {
-                                    readonly key: 'dataforseo';
-                                    readonly units: 1;
-                                };
+                            readonly competitor: {
+                                readonly id: 'c_example';
+                                readonly domain: 'rival.com';
                             };
+                            readonly status: 'queued';
                         };
                         readonly meta: {
-                            readonly requestId: 'req_01JXYZ';
+                            readonly requestId: 'req_example';
                             readonly version: '1.0';
                         };
                     };
@@ -4468,67 +5784,37 @@ export declare const researchV1Registry: import("./core.js").PublicV1Registry<{
             }];
         };
     };
-    readonly domainAvailability: {
-        readonly id: 'research.domain.availability';
-        readonly method: 'GET';
-        readonly path: '/api/v1/sites/{siteId}/research/domain-availability';
+    readonly removeCompetitor: {
+        readonly id: 'research.competitors.remove';
+        readonly method: 'DELETE';
+        readonly path: '/api/v1/sites/{siteId}/research/competitors/{competitorId}';
         readonly visibility: 'public';
         readonly semantics: {
-            readonly kind: 'query';
-            readonly sideEffects: 'none';
-            readonly retry: 'idempotent';
-            readonly readConsistency: 'primary';
+            readonly kind: 'mutation';
+            readonly sideEffects: 'state';
+            readonly retry: 'never';
+            readonly readConsistency: null;
         };
         readonly auth: {
             readonly credentials: readonly ['session', 'api_token'];
-            readonly scopes: readonly ['research:read'];
-            readonly minimumRole: 'viewer';
+            readonly scopes: readonly ['research:write'];
+            readonly minimumRole: 'member';
             readonly ownership: 'site';
         };
         readonly request: {
             readonly params: z.ZodObject<{
                 siteId: z.ZodString;
+                competitorId: z.ZodString;
             }, z.core.$strict>;
-            readonly query: z.ZodObject<{
-                domains: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodPipe<z.ZodString, z.ZodTransform<string[], string>>]>;
-            }, 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<{
-                    readonly results: z.ZodArray<z.ZodObject<{
-                        readonly domain: z.ZodString;
-                        readonly available: z.ZodBoolean;
-                        readonly registrar: z.ZodNullable<z.ZodString>;
-                        readonly expiration: z.ZodNullable<z.ZodString>;
-                        readonly created: z.ZodNullable<z.ZodString>;
-                        readonly note: z.ZodNullable<z.ZodString>;
-                    }, z.core.$strip>>;
-                    readonly message: z.ZodNullable<z.ZodString>;
-                    readonly evidence: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                        _tag: z.ZodLiteral<"no-provider">;
-                        provider: z.ZodNull;
-                        spend: z.ZodObject<{
-                            key: z.ZodLiteral<"dataforseo">;
-                            units: z.ZodLiteral<0>;
-                        }, z.core.$strict>;
-                    }, z.core.$strict>, z.ZodObject<{
-                        _tag: z.ZodLiteral<"cache">;
-                        provider: z.ZodLiteral<"dataforseo">;
-                        spend: z.ZodObject<{
-                            key: z.ZodLiteral<"dataforseo">;
-                            units: z.ZodLiteral<0>;
-                        }, z.core.$strict>;
-                    }, z.core.$strict>, z.ZodObject<{
-                        _tag: z.ZodLiteral<"live">;
-                        provider: z.ZodLiteral<"dataforseo">;
-                        spend: z.ZodObject<{
-                            key: z.ZodLiteral<"dataforseo">;
-                            units: z.ZodLiteral<1>;
-                        }, z.core.$strict>;
-                    }, z.core.$strict>], "_tag">;
+                    readonly competitorId: z.ZodString;
+                    readonly deleted: z.ZodLiteral<true>;
                 }, z.core.$strip>;
                 meta: z.ZodObject<{
                     requestId: z.ZodString;
@@ -4536,37 +5822,8 @@ export declare const researchV1Registry: import("./core.js").PublicV1Registry<{
                 }, z.core.$strict>;
             }, z.core.$strip>, z.ZodObject<{
                 data: z.ZodObject<{
-                    readonly results: z.ZodArray<z.ZodObject<{
-                        readonly domain: z.ZodString;
-                        readonly available: z.ZodBoolean;
-                        readonly registrar: z.ZodNullable<z.ZodString>;
-                        readonly expiration: z.ZodNullable<z.ZodString>;
-                        readonly created: z.ZodNullable<z.ZodString>;
-                        readonly note: z.ZodNullable<z.ZodString>;
-                    }, z.core.$strip>>;
-                    readonly message: z.ZodNullable<z.ZodString>;
-                    readonly evidence: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                        _tag: z.ZodLiteral<"no-provider">;
-                        provider: z.ZodNull;
-                        spend: z.ZodObject<{
-                            key: z.ZodLiteral<"dataforseo">;
-                            units: z.ZodLiteral<0>;
-                        }, z.core.$loose>;
-                    }, z.core.$loose>, z.ZodObject<{
-                        _tag: z.ZodLiteral<"cache">;
-                        provider: z.ZodLiteral<"dataforseo">;
-                        spend: z.ZodObject<{
-                            key: z.ZodLiteral<"dataforseo">;
-                            units: z.ZodLiteral<0>;
-                        }, z.core.$loose>;
-                    }, z.core.$loose>, z.ZodObject<{
-                        _tag: z.ZodLiteral<"live">;
-                        provider: z.ZodLiteral<"dataforseo">;
-                        spend: z.ZodObject<{
-                            key: z.ZodLiteral<"dataforseo">;
-                            units: z.ZodLiteral<1>;
-                        }, z.core.$loose>;
-                    }, z.core.$loose>], "_tag">;
+                    readonly competitorId: z.ZodString;
+                    readonly deleted: z.ZodLiteral<true>;
                 }, z.core.$strip>;
                 meta: z.ZodObject<{
                     requestId: z.ZodString;
@@ -4627,7 +5884,10 @@ export declare const researchV1Registry: import("./core.js").PublicV1Registry<{
                 readonly type: 'site.research';
                 readonly idFrom: 'params.siteId';
             }];
-            readonly changes: readonly [];
+            readonly changes: readonly [{
+                readonly type: 'site.research';
+                readonly idFrom: 'params.siteId';
+            }];
         };
         readonly policy: {
             readonly rate: {
@@ -4638,53 +5898,32 @@ export declare const researchV1Registry: import("./core.js").PublicV1Registry<{
             readonly idempotency: {
                 readonly _tag: 'none';
             };
-            readonly entitlement: 'growth';
-            readonly meter: {
-                readonly key: 'dataforseo';
-                readonly units: 1;
-                readonly charge: 'live-only';
-            };
+            readonly entitlement: null;
+            readonly meter: null;
         };
         readonly lifecycle: {
             readonly introduced: '1.2.0';
         };
         readonly docs: {
-            readonly summary: 'Check domain availability';
-            readonly description: 'Returns the registration status of up to ten domains, with the registrar and expiry when the domain is taken. Repeat the domains parameter for each domain. Cached reads consume no units.';
+            readonly summary: 'Remove one tracked competitor';
+            readonly description: 'Removes a competitor from this Site using its listed id. Removal starts no provider work.';
             readonly tags: readonly ["Research"];
             readonly examples: readonly [{
                 readonly request: {
                     readonly params: {
-                        readonly siteId: 'site_01JXYZ';
-                    };
-                    readonly query: {
-                        readonly domains: readonly ["example.com", "example.dev"];
+                        readonly siteId: 's_example';
+                        readonly competitorId: 'c_example';
                     };
                 };
                 readonly response: {
                     readonly status: 200;
                     readonly body: {
                         readonly data: {
-                            readonly results: readonly [{
-                                readonly domain: 'example.com';
-                                readonly available: false;
-                                readonly registrar: 'Example Registrar';
-                                readonly expiration: '2027-04-01';
-                                readonly created: '1995-08-14';
-                                readonly note: null;
-                            }];
-                            readonly message: null;
-                            readonly evidence: {
-                                readonly _tag: 'live';
-                                readonly provider: 'dataforseo';
-                                readonly spend: {
-                                    readonly key: 'dataforseo';
-                                    readonly units: 1;
-                                };
-                            };
+                            readonly competitorId: 'c_example';
+                            readonly deleted: true;
                         };
                         readonly meta: {
-                            readonly requestId: 'req_01JXYZ';
+                            readonly requestId: 'req_example';
                             readonly version: '1.0';
                         };
                     };