@nuxtseo/protocol 0.1.5 → 0.2.1

package/dist/v1/actions.d.ts

@@ -2122,6 +2122,199 @@ export declare const actionResolveOperation: {
         }];
     };
 };
+export declare const actionDismissDataSchema: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
+    readonly actionId: z.ZodString;
+    readonly status: z.ZodString;
+    readonly message: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    readonly actionId: z.ZodString;
+    readonly status: z.ZodString;
+    readonly message: z.ZodString;
+}, z.core.$strip>>;
+export declare const actionDismissResponseSchema: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
+    data: z.ZodObject<{
+        readonly actionId: z.ZodString;
+        readonly status: z.ZodString;
+        readonly message: z.ZodString;
+    }, 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 actionId: z.ZodString;
+        readonly status: z.ZodString;
+        readonly message: z.ZodString;
+    }, z.core.$strip>;
+    meta: z.ZodObject<{
+        requestId: z.ZodString;
+        version: z.ZodLiteral<"1.0">;
+    }, z.core.$loose>;
+}, z.core.$strip>>;
+export type ActionDismiss = z.output<typeof actionDismissDataSchema.client>;
+/**
+ * Dismissing is the opposite decision from resolving: the page stays gone.
+ * It is admitted only for a broken-page Action whose evidence is complete and
+ * shows no internal referrer, so a caller cannot use it to hide work. The same
+ * `artifactVersion` fence as resolve applies, so a decision made against stale
+ * evidence is rejected rather than applied.
+ */
+export declare const actionDismissOperation: {
+    readonly id: 'actions.dismiss';
+    readonly method: 'POST';
+    readonly path: '/api/v1/sites/{siteId}/actions/{actionId}/dismiss';
+    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 ["actions:write"];
+        readonly minimumRole: 'member';
+        readonly ownership: 'site';
+    };
+    readonly request: {
+        readonly params: z.ZodObject<{
+            siteId: z.ZodString;
+            actionId: z.ZodString;
+        }, z.core.$strict>;
+        readonly query: null;
+        readonly headers: null;
+        readonly body: z.ZodObject<{
+            artifactVersion: z.ZodString;
+        }, z.core.$strict>;
+    };
+    readonly responses: {
+        readonly 200: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
+            data: z.ZodObject<{
+                readonly actionId: z.ZodString;
+                readonly status: z.ZodString;
+                readonly message: z.ZodString;
+            }, 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 actionId: z.ZodString;
+                readonly status: z.ZodString;
+                readonly message: z.ZodString;
+            }, 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", "entitlement_required", "not_found", "stale_evidence", "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.actions';
+            readonly idFrom: 'params.siteId';
+        }];
+        readonly changes: readonly [{
+            readonly type: 'site.actions';
+            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: 'Dismiss an action';
+        readonly description: 'Dismisses a broken-page action when its evidence is complete and shows no internal referrers, so the removed page stays removed. It is rejected when the action has other evidence, when it is already decided, or when the artifactVersion no longer matches. The action stays dismissed until a person restores it.';
+        readonly tags: readonly ["Actions"];
+        readonly examples: readonly [{
+            readonly request: {
+                readonly params: {
+                    readonly siteId: 'site_01JXYZ';
+                    readonly actionId: 'action_01JXYZ';
+                };
+                readonly body: {
+                    readonly artifactVersion: 'te2:action_01JXYZ:scope';
+                };
+            };
+            readonly response: {
+                readonly status: 200;
+                readonly body: {
+                    readonly data: {
+                        readonly actionId: 'action_01JXYZ';
+                        readonly status: 'dismissed';
+                        readonly message: 'Dismissed. This page can stay removed.';
+                    };
+                    readonly meta: {
+                        readonly requestId: 'req_01JXYZ';
+                        readonly version: '1.0';
+                    };
+                };
+            };
+        }];
+    };
+};
 export declare const actionsV1Registry: import("./core.js").PublicV1Registry<{
     readonly list: {
         readonly id: 'actions.list';
@@ -2945,4 +3138,159 @@ export declare const actionsV1Registry: import("./core.js").PublicV1Registry<{
             }];
         };
     };
+    readonly dismiss: {
+        readonly id: 'actions.dismiss';
+        readonly method: 'POST';
+        readonly path: '/api/v1/sites/{siteId}/actions/{actionId}/dismiss';
+        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 ["actions:write"];
+            readonly minimumRole: 'member';
+            readonly ownership: 'site';
+        };
+        readonly request: {
+            readonly params: z.ZodObject<{
+                siteId: z.ZodString;
+                actionId: z.ZodString;
+            }, z.core.$strict>;
+            readonly query: null;
+            readonly headers: null;
+            readonly body: z.ZodObject<{
+                artifactVersion: z.ZodString;
+            }, z.core.$strict>;
+        };
+        readonly responses: {
+            readonly 200: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
+                data: z.ZodObject<{
+                    readonly actionId: z.ZodString;
+                    readonly status: z.ZodString;
+                    readonly message: z.ZodString;
+                }, 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 actionId: z.ZodString;
+                    readonly status: z.ZodString;
+                    readonly message: z.ZodString;
+                }, 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", "entitlement_required", "not_found", "stale_evidence", "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.actions';
+                readonly idFrom: 'params.siteId';
+            }];
+            readonly changes: readonly [{
+                readonly type: 'site.actions';
+                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: 'Dismiss an action';
+            readonly description: 'Dismisses a broken-page action when its evidence is complete and shows no internal referrers, so the removed page stays removed. It is rejected when the action has other evidence, when it is already decided, or when the artifactVersion no longer matches. The action stays dismissed until a person restores it.';
+            readonly tags: readonly ["Actions"];
+            readonly examples: readonly [{
+                readonly request: {
+                    readonly params: {
+                        readonly siteId: 'site_01JXYZ';
+                        readonly actionId: 'action_01JXYZ';
+                    };
+                    readonly body: {
+                        readonly artifactVersion: 'te2:action_01JXYZ:scope';
+                    };
+                };
+                readonly response: {
+                    readonly status: 200;
+                    readonly body: {
+                        readonly data: {
+                            readonly actionId: 'action_01JXYZ';
+                            readonly status: 'dismissed';
+                            readonly message: 'Dismissed. This page can stay removed.';
+                        };
+                        readonly meta: {
+                            readonly requestId: 'req_01JXYZ';
+                            readonly version: '1.0';
+                        };
+                    };
+                };
+            }];
+        };
+    };
 }>;

package/dist/v1/actions.js

@@ -485,11 +485,87 @@ export const actionResolveOperation = defineOperation({
             }],
     },
 });
+export const actionDismissDataSchema = defineResponseObject({
+    actionId: schema.string().min(1),
+    status: schema.string().min(1),
+    message: schema.string().min(1),
+}, {
+    actionId: schema.string().min(1),
+    status: schema.string().min(1),
+    message: schema.string().min(1),
+});
+export const actionDismissResponseSchema = defineSuccessEnvelope(actionDismissDataSchema);
+/**
+ * Dismissing is the opposite decision from resolving: the page stays gone.
+ * It is admitted only for a broken-page Action whose evidence is complete and
+ * shows no internal referrer, so a caller cannot use it to hide work. The same
+ * `artifactVersion` fence as resolve applies, so a decision made against stale
+ * evidence is rejected rather than applied.
+ */
+export const actionDismissOperation = defineOperation({
+    id: 'actions.dismiss',
+    method: 'POST',
+    path: '/api/v1/sites/{siteId}/actions/{actionId}/dismiss',
+    visibility: 'public',
+    semantics: { kind: 'mutation', sideEffects: 'state', retry: 'never', readConsistency: null },
+    auth: {
+        credentials: ['session', 'api_token'],
+        scopes: ['actions:write'],
+        minimumRole: 'member',
+        ownership: 'site',
+    },
+    request: { params: actionParamsSchema, query: null, headers: null, body: actionResolveBodySchema },
+    responses: { 200: actionDismissResponseSchema },
+    errors: [
+        'invalid_request',
+        'unauthorized',
+        'auth_expired',
+        'forbidden',
+        'entitlement_required',
+        'not_found',
+        'stale_evidence',
+        'conflict',
+        'rate_limited',
+        'contract_violation',
+        'internal_error',
+    ],
+    errorResponse: publicV1ErrorEnvelope,
+    resources: {
+        reads: [{ type: 'site.actions', idFrom: 'params.siteId' }],
+        changes: [{ type: 'site.actions', idFrom: 'params.siteId' }],
+    },
+    policy: {
+        rate: publicV1StandardRatePolicy,
+        idempotency: { _tag: 'none' },
+        entitlement: null,
+        meter: null,
+    },
+    lifecycle: { introduced: '1.2.0' },
+    docs: {
+        summary: 'Dismiss an action',
+        description: 'Dismisses a broken-page action when its evidence is complete and shows no internal referrers, so the removed page stays removed. It is rejected when the action has other evidence, when it is already decided, or when the artifactVersion no longer matches. The action stays dismissed until a person restores it.',
+        tags: ['Actions'],
+        examples: [{
+                request: {
+                    params: { siteId: 'site_01JXYZ', actionId: 'action_01JXYZ' },
+                    body: { artifactVersion: 'te2:action_01JXYZ:scope' },
+                },
+                response: {
+                    status: 200,
+                    body: {
+                        data: { actionId: 'action_01JXYZ', status: 'dismissed', message: 'Dismissed. This page can stay removed.' },
+                        meta: { requestId: 'req_01JXYZ', version: '1.0' },
+                    },
+                },
+            }],
+    },
+});
 export const actionsV1Registry = defineRegistry({
     feature: 'actions',
     operations: {
         list: actionListOperation,
         show: actionShowOperation,
         resolve: actionResolveOperation,
+        dismiss: actionDismissOperation,
     },
 });

package/dist/v1/audit.d.ts

@@ -1027,6 +1027,13 @@ export declare const auditDuplicateClustersDataSchema: import("./core.js").Compa
     }, z.core.$strip>>;
     readonly total: z.ZodNumber;
     readonly pagesAffected: z.ZodNumber;
+    /**
+     * The crawl the clusters came from, null when the site has never completed
+     * one. The reader always knew this and the route dropped it, so a consumer
+     * could not tell "no duplicates" from "never looked" — both arrive as
+     * `total: 0`. Optional so a payload cached before this field still parses.
+     */
+    readonly crawlSettingsId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
 }, z.core.$strip>, z.ZodObject<{
     readonly connected: z.ZodBoolean;
     readonly clusters: z.ZodArray<z.ZodObject<{
@@ -1053,6 +1060,7 @@ export declare const auditDuplicateClustersDataSchema: import("./core.js").Compa
     }, z.core.$strip>>;
     readonly total: z.ZodNumber;
     readonly pagesAffected: z.ZodNumber;
+    readonly crawlSettingsId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
 }, z.core.$strip>>;
 export declare const auditDuplicateClustersResponseSchema: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
     data: z.ZodObject<{
@@ -1081,6 +1089,13 @@ export declare const auditDuplicateClustersResponseSchema: import("./core.js").C
         }, z.core.$strip>>;
         readonly total: z.ZodNumber;
         readonly pagesAffected: z.ZodNumber;
+        /**
+         * The crawl the clusters came from, null when the site has never completed
+         * one. The reader always knew this and the route dropped it, so a consumer
+         * could not tell "no duplicates" from "never looked" — both arrive as
+         * `total: 0`. Optional so a payload cached before this field still parses.
+         */
+        readonly crawlSettingsId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
     }, z.core.$strip>;
     meta: z.ZodObject<{
         requestId: z.ZodString;
@@ -1113,6 +1128,7 @@ export declare const auditDuplicateClustersResponseSchema: import("./core.js").C
         }, z.core.$strip>>;
         readonly total: z.ZodNumber;
         readonly pagesAffected: z.ZodNumber;
+        readonly crawlSettingsId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
     }, z.core.$strip>;
     meta: z.ZodObject<{
         requestId: z.ZodString;
@@ -2165,6 +2181,13 @@ export declare const auditDuplicateClustersOperation: {
                 }, z.core.$strip>>;
                 readonly total: z.ZodNumber;
                 readonly pagesAffected: z.ZodNumber;
+                /**
+                 * The crawl the clusters came from, null when the site has never completed
+                 * one. The reader always knew this and the route dropped it, so a consumer
+                 * could not tell "no duplicates" from "never looked" — both arrive as
+                 * `total: 0`. Optional so a payload cached before this field still parses.
+                 */
+                readonly crawlSettingsId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
             }, z.core.$strip>;
             meta: z.ZodObject<{
                 requestId: z.ZodString;
@@ -2197,6 +2220,7 @@ export declare const auditDuplicateClustersOperation: {
                 }, z.core.$strip>>;
                 readonly total: z.ZodNumber;
                 readonly pagesAffected: z.ZodNumber;
+                readonly crawlSettingsId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
             }, z.core.$strip>;
             meta: z.ZodObject<{
                 requestId: z.ZodString;
@@ -3472,6 +3496,13 @@ export declare const auditV1Registry: import("./core.js").PublicV1Registry<{
                     }, z.core.$strip>>;
                     readonly total: z.ZodNumber;
                     readonly pagesAffected: z.ZodNumber;
+                    /**
+                     * The crawl the clusters came from, null when the site has never completed
+                     * one. The reader always knew this and the route dropped it, so a consumer
+                     * could not tell "no duplicates" from "never looked" — both arrive as
+                     * `total: 0`. Optional so a payload cached before this field still parses.
+                     */
+                    readonly crawlSettingsId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                 }, z.core.$strip>;
                 meta: z.ZodObject<{
                     requestId: z.ZodString;
@@ -3504,6 +3535,7 @@ export declare const auditV1Registry: import("./core.js").PublicV1Registry<{
                     }, z.core.$strip>>;
                     readonly total: z.ZodNumber;
                     readonly pagesAffected: z.ZodNumber;
+                    readonly crawlSettingsId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                 }, z.core.$strip>;
                 meta: z.ZodObject<{
                     requestId: z.ZodString;

package/dist/v1/audit.js

@@ -199,11 +199,19 @@ export const auditDuplicateClustersDataSchema = defineResponseObject({
     clusters: schema.array(duplicateClusterSchema.producer),
     total: schema.number(),
     pagesAffected: schema.number(),
+    /**
+     * The crawl the clusters came from, null when the site has never completed
+     * one. The reader always knew this and the route dropped it, so a consumer
+     * could not tell "no duplicates" from "never looked" — both arrive as
+     * `total: 0`. Optional so a payload cached before this field still parses.
+     */
+    crawlSettingsId: schema.number().nullable().optional(),
 }, {
     connected: schema.boolean(),
     clusters: schema.array(duplicateClusterSchema.client),
     total: schema.number(),
     pagesAffected: schema.number(),
+    crawlSettingsId: schema.number().nullable().optional(),
 });
 export const auditDuplicateClustersResponseSchema = defineSuccessEnvelope(auditDuplicateClustersDataSchema);
 export const linkOpportunityRowSchema = defineResponseObject({