@nuxtseo/protocol 0.1.3 → 0.1.4

package/dist/v1/timeline.d.ts

@@ -0,0 +1,517 @@
+import type { z } from 'zod';
+export declare const timelineSiteParamsSchema: z.ZodObject<{
+    siteId: z.ZodString;
+}, z.core.$strict>;
+export declare const timelineEntrySeveritySchema: z.ZodEnum<{
+    high: "high";
+    info: "info";
+    notable: "notable";
+}>;
+export declare const timelineEntriesQuerySchema: z.ZodObject<{
+    kinds: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string[] | undefined, string | undefined>>;
+    feature: z.ZodOptional<z.ZodString>;
+    severity: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<("high" | "info" | "notable")[] | undefined, string | undefined>>;
+    since: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    cursor: z.ZodOptional<z.ZodString>;
+    includeClosed: z.ZodPipe<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>>, z.ZodTransform<boolean, "false" | "true" | boolean>>;
+}, z.core.$strict>;
+export declare const timelineEntrySchema: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
+    readonly id: z.ZodString;
+    readonly kind: z.ZodString;
+    readonly severity: z.ZodNullable<z.ZodEnum<{
+        high: "high";
+        info: "info";
+        notable: "notable";
+    }>>;
+    readonly occurredAt: z.ZodString;
+    readonly rendered: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    readonly payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    readonly id: z.ZodString;
+    readonly kind: z.ZodString;
+    readonly severity: z.ZodNullable<z.ZodEnum<{
+        high: "high";
+        info: "info";
+        notable: "notable";
+    }>>;
+    readonly occurredAt: z.ZodString;
+    readonly rendered: z.ZodNullable<z.ZodObject<{}, z.core.$loose>>;
+    readonly payload: z.ZodObject<{}, z.core.$loose>;
+}, z.core.$strip>>;
+export declare const timelineEntriesDataSchema: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
+    readonly entries: z.ZodArray<z.ZodObject<{
+        readonly id: z.ZodString;
+        readonly kind: z.ZodString;
+        readonly severity: z.ZodNullable<z.ZodEnum<{
+            high: "high";
+            info: "info";
+            notable: "notable";
+        }>>;
+        readonly occurredAt: z.ZodString;
+        readonly rendered: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        readonly payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>>;
+    readonly nextCursor: z.ZodNullable<z.ZodString>;
+    readonly counts: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    readonly entries: z.ZodArray<z.ZodObject<{
+        readonly id: z.ZodString;
+        readonly kind: z.ZodString;
+        readonly severity: z.ZodNullable<z.ZodEnum<{
+            high: "high";
+            info: "info";
+            notable: "notable";
+        }>>;
+        readonly occurredAt: z.ZodString;
+        readonly rendered: z.ZodNullable<z.ZodObject<{}, z.core.$loose>>;
+        readonly payload: z.ZodObject<{}, z.core.$loose>;
+    }, z.core.$strip>>;
+    readonly nextCursor: z.ZodNullable<z.ZodString>;
+    readonly counts: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, z.core.$strip>>;
+export declare const timelineEntriesResponseSchema: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
+    data: z.ZodObject<{
+        readonly entries: z.ZodArray<z.ZodObject<{
+            readonly id: z.ZodString;
+            readonly kind: z.ZodString;
+            readonly severity: z.ZodNullable<z.ZodEnum<{
+                high: "high";
+                info: "info";
+                notable: "notable";
+            }>>;
+            readonly occurredAt: z.ZodString;
+            readonly rendered: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            readonly payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>>;
+        readonly nextCursor: z.ZodNullable<z.ZodString>;
+        readonly counts: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    }, z.core.$strip>;
+    meta: z.ZodObject<{
+        requestId: z.ZodString;
+        version: z.ZodLiteral<"1.0">;
+    }, z.core.$strict>;
+}, z.core.$strip>, z.ZodObject<{
+    data: z.ZodObject<{
+        readonly entries: z.ZodArray<z.ZodObject<{
+            readonly id: z.ZodString;
+            readonly kind: z.ZodString;
+            readonly severity: z.ZodNullable<z.ZodEnum<{
+                high: "high";
+                info: "info";
+                notable: "notable";
+            }>>;
+            readonly occurredAt: z.ZodString;
+            readonly rendered: z.ZodNullable<z.ZodObject<{}, z.core.$loose>>;
+            readonly payload: z.ZodObject<{}, z.core.$loose>;
+        }, z.core.$strip>>;
+        readonly nextCursor: z.ZodNullable<z.ZodString>;
+        readonly counts: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    }, z.core.$strip>;
+    meta: z.ZodObject<{
+        requestId: z.ZodString;
+        version: z.ZodLiteral<"1.0">;
+    }, z.core.$loose>;
+}, z.core.$strip>>;
+export type TimelineSiteParams = z.input<typeof timelineSiteParamsSchema>;
+export type TimelineEntriesQuery = z.input<typeof timelineEntriesQuerySchema>;
+export type TimelineEntry = z.output<typeof timelineEntrySchema.client>;
+export type TimelineEntries = z.output<typeof timelineEntriesDataSchema.client>;
+export type TimelineEntriesResponse = z.output<typeof timelineEntriesResponseSchema.client>;
+export declare const timelineEntriesOperation: {
+    readonly id: 'timeline.entries';
+    readonly method: 'GET';
+    readonly path: '/api/v1/sites/{siteId}/timeline';
+    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 ['timeline:read'];
+        readonly minimumRole: 'viewer';
+        readonly ownership: 'site';
+    };
+    readonly request: {
+        readonly params: z.ZodObject<{
+            siteId: z.ZodString;
+        }, z.core.$strict>;
+        readonly query: z.ZodObject<{
+            kinds: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string[] | undefined, string | undefined>>;
+            feature: z.ZodOptional<z.ZodString>;
+            severity: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<("high" | "info" | "notable")[] | undefined, string | undefined>>;
+            since: z.ZodOptional<z.ZodString>;
+            limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+            cursor: z.ZodOptional<z.ZodString>;
+            includeClosed: z.ZodPipe<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+                false: "false";
+                true: "true";
+            }>]>>, z.ZodTransform<boolean, "false" | "true" | boolean>>;
+        }, z.core.$strict>;
+        readonly headers: null;
+        readonly body: null;
+    };
+    readonly responses: {
+        readonly 200: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
+            data: z.ZodObject<{
+                readonly entries: z.ZodArray<z.ZodObject<{
+                    readonly id: z.ZodString;
+                    readonly kind: z.ZodString;
+                    readonly severity: z.ZodNullable<z.ZodEnum<{
+                        high: "high";
+                        info: "info";
+                        notable: "notable";
+                    }>>;
+                    readonly occurredAt: z.ZodString;
+                    readonly rendered: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    readonly payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                }, z.core.$strip>>;
+                readonly nextCursor: z.ZodNullable<z.ZodString>;
+                readonly counts: z.ZodRecord<z.ZodString, z.ZodNumber>;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+                requestId: z.ZodString;
+                version: z.ZodLiteral<"1.0">;
+            }, z.core.$strict>;
+        }, z.core.$strip>, z.ZodObject<{
+            data: z.ZodObject<{
+                readonly entries: z.ZodArray<z.ZodObject<{
+                    readonly id: z.ZodString;
+                    readonly kind: z.ZodString;
+                    readonly severity: z.ZodNullable<z.ZodEnum<{
+                        high: "high";
+                        info: "info";
+                        notable: "notable";
+                    }>>;
+                    readonly occurredAt: z.ZodString;
+                    readonly rendered: z.ZodNullable<z.ZodObject<{}, z.core.$loose>>;
+                    readonly payload: z.ZodObject<{}, z.core.$loose>;
+                }, z.core.$strip>>;
+                readonly nextCursor: z.ZodNullable<z.ZodString>;
+                readonly counts: z.ZodRecord<z.ZodString, z.ZodNumber>;
+            }, z.core.$strip>;
+            meta: z.ZodObject<{
+                requestId: z.ZodString;
+                version: z.ZodLiteral<"1.0">;
+            }, z.core.$loose>;
+        }, z.core.$strip>>;
+    };
+    readonly errors: readonly ["invalid_request", "unauthorized", "auth_expired", "forbidden", "not_found", "rate_limited", "provider_unavailable", "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.timeline';
+            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: 'Read the Timeline';
+        readonly description: 'What changed on this Site — Timeline Entries such as traffic drops, indexing changes, sitemap changes, rank shifts and deploys. Filter by kind, feature, severity and since; paginated with an opaque cursor.';
+        readonly tags: readonly ["Timeline"];
+        readonly examples: readonly [{
+            readonly request: {
+                readonly params: {
+                    readonly siteId: 'site_01JXYZ';
+                };
+                readonly query: {
+                    readonly severity: 'high';
+                };
+            };
+            readonly response: {
+                readonly status: 200;
+                readonly body: {
+                    readonly data: {
+                        readonly entries: readonly [{
+                            readonly id: 'timeline_01JXYZ';
+                            readonly kind: 'traffic.dropped';
+                            readonly severity: 'high';
+                            readonly occurredAt: '2026-08-10T01:30:00.000Z';
+                            readonly rendered: {
+                                readonly label: 'Clicks dropped 42%';
+                                readonly value: -0.42;
+                                readonly direction: 'down';
+                            };
+                            readonly payload: {
+                                readonly clicksDelta: -180;
+                            };
+                        }];
+                        readonly nextCursor: null;
+                        readonly counts: {
+                            readonly 'traffic.dropped': 1;
+                        };
+                    };
+                    readonly meta: {
+                        readonly requestId: 'req_01JXYZ';
+                        readonly version: '1.0';
+                    };
+                };
+            };
+        }];
+    };
+};
+export declare const timelineV1Registry: import("./core.js").PublicV1Registry<{
+    readonly entries: {
+        readonly id: 'timeline.entries';
+        readonly method: 'GET';
+        readonly path: '/api/v1/sites/{siteId}/timeline';
+        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 ['timeline:read'];
+            readonly minimumRole: 'viewer';
+            readonly ownership: 'site';
+        };
+        readonly request: {
+            readonly params: z.ZodObject<{
+                siteId: z.ZodString;
+            }, z.core.$strict>;
+            readonly query: z.ZodObject<{
+                kinds: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string[] | undefined, string | undefined>>;
+                feature: z.ZodOptional<z.ZodString>;
+                severity: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<("high" | "info" | "notable")[] | undefined, string | undefined>>;
+                since: z.ZodOptional<z.ZodString>;
+                limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+                cursor: z.ZodOptional<z.ZodString>;
+                includeClosed: z.ZodPipe<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+                    false: "false";
+                    true: "true";
+                }>]>>, z.ZodTransform<boolean, "false" | "true" | boolean>>;
+            }, z.core.$strict>;
+            readonly headers: null;
+            readonly body: null;
+        };
+        readonly responses: {
+            readonly 200: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
+                data: z.ZodObject<{
+                    readonly entries: z.ZodArray<z.ZodObject<{
+                        readonly id: z.ZodString;
+                        readonly kind: z.ZodString;
+                        readonly severity: z.ZodNullable<z.ZodEnum<{
+                            high: "high";
+                            info: "info";
+                            notable: "notable";
+                        }>>;
+                        readonly occurredAt: z.ZodString;
+                        readonly rendered: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        readonly payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                    }, z.core.$strip>>;
+                    readonly nextCursor: z.ZodNullable<z.ZodString>;
+                    readonly counts: z.ZodRecord<z.ZodString, z.ZodNumber>;
+                }, z.core.$strip>;
+                meta: z.ZodObject<{
+                    requestId: z.ZodString;
+                    version: z.ZodLiteral<"1.0">;
+                }, z.core.$strict>;
+            }, z.core.$strip>, z.ZodObject<{
+                data: z.ZodObject<{
+                    readonly entries: z.ZodArray<z.ZodObject<{
+                        readonly id: z.ZodString;
+                        readonly kind: z.ZodString;
+                        readonly severity: z.ZodNullable<z.ZodEnum<{
+                            high: "high";
+                            info: "info";
+                            notable: "notable";
+                        }>>;
+                        readonly occurredAt: z.ZodString;
+                        readonly rendered: z.ZodNullable<z.ZodObject<{}, z.core.$loose>>;
+                        readonly payload: z.ZodObject<{}, z.core.$loose>;
+                    }, z.core.$strip>>;
+                    readonly nextCursor: z.ZodNullable<z.ZodString>;
+                    readonly counts: z.ZodRecord<z.ZodString, z.ZodNumber>;
+                }, z.core.$strip>;
+                meta: z.ZodObject<{
+                    requestId: z.ZodString;
+                    version: z.ZodLiteral<"1.0">;
+                }, z.core.$loose>;
+            }, z.core.$strip>>;
+        };
+        readonly errors: readonly ["invalid_request", "unauthorized", "auth_expired", "forbidden", "not_found", "rate_limited", "provider_unavailable", "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.timeline';
+                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: 'Read the Timeline';
+            readonly description: 'What changed on this Site — Timeline Entries such as traffic drops, indexing changes, sitemap changes, rank shifts and deploys. Filter by kind, feature, severity and since; paginated with an opaque cursor.';
+            readonly tags: readonly ["Timeline"];
+            readonly examples: readonly [{
+                readonly request: {
+                    readonly params: {
+                        readonly siteId: 'site_01JXYZ';
+                    };
+                    readonly query: {
+                        readonly severity: 'high';
+                    };
+                };
+                readonly response: {
+                    readonly status: 200;
+                    readonly body: {
+                        readonly data: {
+                            readonly entries: readonly [{
+                                readonly id: 'timeline_01JXYZ';
+                                readonly kind: 'traffic.dropped';
+                                readonly severity: 'high';
+                                readonly occurredAt: '2026-08-10T01:30:00.000Z';
+                                readonly rendered: {
+                                    readonly label: 'Clicks dropped 42%';
+                                    readonly value: -0.42;
+                                    readonly direction: 'down';
+                                };
+                                readonly payload: {
+                                    readonly clicksDelta: -180;
+                                };
+                            }];
+                            readonly nextCursor: null;
+                            readonly counts: {
+                                readonly 'traffic.dropped': 1;
+                            };
+                        };
+                        readonly meta: {
+                            readonly requestId: 'req_01JXYZ';
+                            readonly version: '1.0';
+                        };
+                    };
+                };
+            }];
+        };
+    };
+}>;

package/dist/v1/timeline.js

@@ -0,0 +1,150 @@
+import { z as schema } from 'zod';
+import { defineOperation, defineRegistry, defineResponseObject, defineSuccessEnvelope, publicV1ErrorEnvelope, publicV1StandardRatePolicy, } from './core.js';
+export const timelineSiteParamsSchema = schema.strictObject({
+    siteId: schema.string().min(1),
+});
+// Mirrors `timelineSeverityEnum` owned by `layers/pro/timeline` (GLOSSARY:
+// Timeline Entry). Duplicated by value, not imported — the protocol package
+// never depends on a Nuxt layer.
+export const timelineEntrySeveritySchema = schema.enum(['info', 'notable', 'high']);
+/** A GET query value repeated as a comma-separated list, e.g. `?kinds=a,b`. */
+function commaListQuerySchema(item) {
+    return schema.string().optional().transform((raw, context) => {
+        if (!raw)
+            return undefined;
+        const parsed = schema.array(item).safeParse(raw.split(',').map(part => part.trim()).filter(Boolean));
+        if (!parsed.success) {
+            context.addIssue({ code: 'custom', message: parsed.error.issues.map(issue => issue.message).join(', ') });
+            return schema.NEVER;
+        }
+        return parsed.data;
+    });
+}
+// Query strings are never real booleans, and coerce.boolean() turns `'false'`
+// into `true`. Parse the two spellings explicitly instead (same pattern as the
+// analytics queries).
+function booleanQuerySchema(fallback) {
+    return schema
+        .union([schema.boolean(), schema.enum(['true', 'false'])])
+        .default(fallback)
+        .transform(value => value === true || value === 'true');
+}
+export const timelineEntriesQuerySchema = schema.strictObject({
+    kinds: commaListQuerySchema(schema.string().min(1)),
+    feature: schema.string().min(1).optional(),
+    severity: commaListQuerySchema(timelineEntrySeveritySchema),
+    since: schema.string().datetime({ offset: true }).optional(),
+    limit: schema.coerce.number().int().min(1).max(100).default(25),
+    cursor: schema.string().min(1).optional(),
+    includeClosed: booleanQuerySchema(false),
+});
+export const timelineEntrySchema = defineResponseObject({
+    id: schema.string(),
+    kind: schema.string(),
+    severity: timelineEntrySeveritySchema.nullable(),
+    occurredAt: schema.string(),
+    rendered: schema.record(schema.string(), schema.unknown()).nullable(),
+    payload: schema.record(schema.string(), schema.unknown()),
+}, {
+    id: schema.string(),
+    kind: schema.string(),
+    severity: timelineEntrySeveritySchema.nullable(),
+    occurredAt: schema.string(),
+    rendered: schema.looseObject({}).nullable(),
+    payload: schema.looseObject({}),
+});
+export const timelineEntriesDataSchema = defineResponseObject({
+    entries: schema.array(timelineEntrySchema.producer),
+    nextCursor: schema.string().nullable(),
+    counts: schema.record(schema.string(), schema.number()),
+}, {
+    entries: schema.array(timelineEntrySchema.client),
+    nextCursor: schema.string().nullable(),
+    counts: schema.record(schema.string(), schema.number()),
+});
+export const timelineEntriesResponseSchema = defineSuccessEnvelope(timelineEntriesDataSchema);
+const timelineReadSemantics = {
+    kind: 'query',
+    sideEffects: 'none',
+    retry: 'idempotent',
+    readConsistency: 'primary',
+};
+const timelineReadAuth = {
+    credentials: ['session', 'api_token'],
+    scopes: ['timeline:read'],
+    minimumRole: 'viewer',
+    ownership: 'site',
+};
+const timelineReadErrors = [
+    'invalid_request',
+    'unauthorized',
+    'auth_expired',
+    'forbidden',
+    'not_found',
+    'rate_limited',
+    'provider_unavailable',
+    'contract_violation',
+    'internal_error',
+];
+const timelineReadResources = {
+    reads: [{ type: 'site.timeline', idFrom: 'params.siteId' }],
+    changes: [],
+};
+const timelineReadPolicy = {
+    rate: publicV1StandardRatePolicy,
+    idempotency: { _tag: 'none' },
+    entitlement: null,
+    meter: null,
+};
+export const timelineEntriesOperation = defineOperation({
+    id: 'timeline.entries',
+    method: 'GET',
+    path: '/api/v1/sites/{siteId}/timeline',
+    visibility: 'public',
+    semantics: timelineReadSemantics,
+    auth: timelineReadAuth,
+    request: {
+        params: timelineSiteParamsSchema,
+        query: timelineEntriesQuerySchema,
+        headers: null,
+        body: null,
+    },
+    responses: { 200: timelineEntriesResponseSchema },
+    errors: timelineReadErrors,
+    errorResponse: publicV1ErrorEnvelope,
+    resources: timelineReadResources,
+    policy: timelineReadPolicy,
+    lifecycle: { introduced: '1.0.0' },
+    docs: {
+        summary: 'Read the Timeline',
+        description: 'What changed on this Site — Timeline Entries such as traffic drops, indexing changes, sitemap changes, rank shifts and deploys. Filter by kind, feature, severity and since; paginated with an opaque cursor.',
+        tags: ['Timeline'],
+        examples: [{
+                request: { params: { siteId: 'site_01JXYZ' }, query: { severity: 'high' } },
+                response: {
+                    status: 200,
+                    body: {
+                        data: {
+                            entries: [{
+                                    id: 'timeline_01JXYZ',
+                                    kind: 'traffic.dropped',
+                                    severity: 'high',
+                                    occurredAt: '2026-08-10T01:30:00.000Z',
+                                    rendered: { label: 'Clicks dropped 42%', value: -0.42, direction: 'down' },
+                                    payload: { clicksDelta: -180 },
+                                }],
+                            nextCursor: null,
+                            counts: { 'traffic.dropped': 1 },
+                        },
+                        meta: { requestId: 'req_01JXYZ', version: '1.0' },
+                    },
+                },
+            }],
+    },
+});
+export const timelineV1Registry = defineRegistry({
+    feature: 'timeline',
+    operations: {
+        entries: timelineEntriesOperation,
+    },
+});