@nuxtseo/protocol 0.1.4 → 0.1.5

package/dist/v1/account.js

@@ -1,5 +1,5 @@
 import { z as schema } from 'zod';
-import { defineOperation, defineRegistry, defineResponseObject, defineSuccessEnvelope, publicV1ErrorEnvelope, publicV1MetaClientSchema, publicV1MetaProducerSchema, publicV1StandardRatePolicy, } from './core.js';
+import { defineOperation, defineRegistry, defineResponseObject, defineSuccessEnvelope, PUBLIC_V1_ROLES, PUBLIC_V1_SCOPES, publicV1ErrorEnvelope, publicV1MetaClientSchema, publicV1MetaProducerSchema, publicV1StandardRatePolicy, } from './core.js';
 export const usageMeterGroupSchema = schema.enum(['integrations', 'compute', 'capacity']);
 export const usageUpgradeTierSchema = schema.enum(['free', 'pro', 'lifetime']);
 export const usagePlanSchema = usageUpgradeTierSchema;
@@ -115,9 +115,128 @@ export const accountUsageOperation = defineOperation({
             }],
     },
 });
+export const accountTokenCredentialSchema = schema.enum(['api_token', 'session']);
+const accountTokenTeamProducerSchema = schema.strictObject({
+    id: schema.string().min(1),
+    name: schema.string().nullable(),
+    plan: usagePlanSchema,
+});
+const accountTokenTeamClientSchema = schema.looseObject({
+    id: schema.string().min(1),
+    name: schema.string().nullable(),
+    plan: usagePlanSchema,
+});
+const accountTokenDetailProducerSchema = schema.strictObject({
+    id: schema.string().min(1),
+    label: schema.string().nullable(),
+    client: schema.string().nullable(),
+    createdAt: schema.iso.datetime().nullable(),
+    lastUsedAt: schema.iso.datetime().nullable(),
+    expiresAt: schema.iso.datetime().nullable(),
+});
+const accountTokenDetailClientSchema = schema.looseObject({
+    id: schema.string().min(1),
+    label: schema.string().nullable(),
+    client: schema.string().nullable(),
+    createdAt: schema.iso.datetime().nullable(),
+    lastUsedAt: schema.iso.datetime().nullable(),
+    expiresAt: schema.iso.datetime().nullable(),
+});
+const accountTokenUserProducerSchema = schema.strictObject({
+    id: schema.string().min(1),
+    email: schema.string().nullable(),
+});
+const accountTokenUserClientSchema = schema.looseObject({
+    id: schema.string().min(1),
+    email: schema.string().nullable(),
+});
+export const accountTokenDataSchema = defineResponseObject({
+    credential: accountTokenCredentialSchema,
+    role: schema.enum(PUBLIC_V1_ROLES),
+    scopes: schema.array(schema.enum(PUBLIC_V1_SCOPES)),
+    team: accountTokenTeamProducerSchema,
+    token: accountTokenDetailProducerSchema.nullable(),
+    user: accountTokenUserProducerSchema,
+}, {
+    credential: accountTokenCredentialSchema,
+    role: schema.enum(PUBLIC_V1_ROLES),
+    scopes: schema.array(schema.enum(PUBLIC_V1_SCOPES)),
+    team: accountTokenTeamClientSchema,
+    token: accountTokenDetailClientSchema.nullable(),
+    user: accountTokenUserClientSchema,
+});
+export const accountTokenResponseSchema = defineSuccessEnvelope(accountTokenDataSchema);
+export const accountTokenOperation = defineOperation({
+    id: 'account.token',
+    method: 'GET',
+    path: '/api/v1/account/token',
+    visibility: 'public',
+    semantics: {
+        kind: 'query',
+        sideEffects: 'none',
+        retry: 'idempotent',
+        readConsistency: 'primary',
+    },
+    auth: {
+        credentials: ['session', 'api_token'],
+        scopes: ['account:read'],
+        minimumRole: 'viewer',
+        ownership: 'team',
+    },
+    request: {
+        params: null,
+        query: null,
+        headers: null,
+        body: null,
+    },
+    responses: { 200: accountTokenResponseSchema },
+    errors: ['unauthorized', 'auth_expired', 'forbidden', 'rate_limited', 'contract_violation', 'internal_error'],
+    errorResponse: publicV1ErrorEnvelope,
+    resources: {
+        reads: [{ type: 'account.usage', idFrom: 'team.id' }],
+        changes: [],
+    },
+    policy: {
+        rate: publicV1StandardRatePolicy,
+        idempotency: { _tag: 'none' },
+        entitlement: null,
+        meter: null,
+    },
+    lifecycle: { introduced: '1.0.0' },
+    docs: {
+        summary: 'Describe the presented credential',
+        description: 'Returns the Team, role, granted scopes, and expiry of the credential on this request. It spends no quota and reads no Site.',
+        tags: ['Account'],
+        examples: [{
+                request: {},
+                response: {
+                    status: 200,
+                    body: {
+                        data: {
+                            credential: 'api_token',
+                            role: 'admin',
+                            scopes: ['account:read', 'sites:read'],
+                            team: { id: 'team_01JXYZ', name: 'Example', plan: 'pro' },
+                            token: {
+                                id: 'token_01JXYZ',
+                                label: 'CLI on laptop',
+                                client: null,
+                                createdAt: '2026-08-01T00:00:00.000Z',
+                                lastUsedAt: '2026-08-20T00:00:00.000Z',
+                                expiresAt: null,
+                            },
+                            user: { id: 'user_01JXYZ', email: 'agent@example.com' },
+                        },
+                        meta: { requestId: 'req_01JXYZ', version: '1.0' },
+                    },
+                },
+            }],
+    },
+});
 export const accountV1Registry = defineRegistry({
     feature: 'account',
     operations: {
         usage: accountUsageOperation,
+        token: accountTokenOperation,
     },
 });

package/dist/v1/backlinks.d.ts

@@ -505,10 +505,12 @@ export declare const backlinksV1Registry: import("./core.js").PublicV1Registry<{
 }>;
 export declare const mentionsQuerySchema: z.ZodObject<{
     limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-    includeFiltered: z.ZodDefault<z.ZodEnum<{
+    includeFiltered: z.ZodPipe<z.ZodDefault<z.ZodEnum<{
         0: "0";
         1: "1";
-    }>>;
+        false: "false";
+        true: "true";
+    }>>, z.ZodTransform<boolean, "0" | "1" | "false" | "true">>;
 }, z.core.$strict>;
 export declare const mentionSchema: import("./core.js").CompatibleResponseSchema<z.ZodObject<{
     readonly id: z.ZodString;
@@ -639,10 +641,12 @@ export declare const mentionsListOperation: {
         }, z.core.$strict>;
         readonly query: z.ZodObject<{
             limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-            includeFiltered: z.ZodDefault<z.ZodEnum<{
+            includeFiltered: z.ZodPipe<z.ZodDefault<z.ZodEnum<{
                 0: "0";
                 1: "1";
-            }>>;
+                false: "false";
+                true: "true";
+            }>>, z.ZodTransform<boolean, "0" | "1" | "false" | "true">>;
         }, z.core.$strict>;
         readonly headers: null;
         readonly body: null;
@@ -831,10 +835,12 @@ export declare const mentionsV1Registry: import("./core.js").PublicV1Registry<{
             }, z.core.$strict>;
             readonly query: z.ZodObject<{
                 limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-                includeFiltered: z.ZodDefault<z.ZodEnum<{
+                includeFiltered: z.ZodPipe<z.ZodDefault<z.ZodEnum<{
                     0: "0";
                     1: "1";
-                }>>;
+                    false: "false";
+                    true: "true";
+                }>>, z.ZodTransform<boolean, "0" | "1" | "false" | "true">>;
             }, z.core.$strict>;
             readonly headers: null;
             readonly body: null;

package/dist/v1/backlinks.js

@@ -1,5 +1,5 @@
 import { z as schema } from 'zod';
-import { defineOperation, defineRegistry, defineResponseObject, defineSuccessEnvelope, publicV1ErrorEnvelope, publicV1StandardRatePolicy, } from './core.js';
+import { defineOperation, defineRegistry, defineResponseObject, defineSuccessEnvelope, publicV1BooleanFlag, publicV1ErrorEnvelope, publicV1StandardRatePolicy, } from './core.js';
 export const backlinksSiteParamsSchema = schema.strictObject({
     siteId: schema.string().min(1),
 });
@@ -126,7 +126,7 @@ export const backlinksV1Registry = defineRegistry({
 });
 export const mentionsQuerySchema = schema.strictObject({
     limit: schema.coerce.number().int().min(1).max(200).default(100),
-    includeFiltered: schema.enum(['0', '1']).default('0'),
+    includeFiltered: publicV1BooleanFlag(false),
 });
 export const mentionSchema = defineResponseObject({
     id: schema.string().min(1),

package/dist/v1/core.d.ts

@@ -172,6 +172,23 @@ export declare function defineProtocol<const TRegistries extends Readonly<Record
 export declare function listOperations<const TProtocol extends PublicV1ProtocolLike>(protocol: TProtocol): PublicV1OperationEntry<TProtocol>[];
 export declare function defineResponseObject<const TProducerShape extends ZodRawShape, const TClientShape extends ZodRawShape = TProducerShape>(producerShape: TProducerShape, clientShape?: TClientShape): CompatibleResponseSchema<z.ZodObject<TProducerShape>, z.ZodObject<TClientShape>>;
 export declare function buildOperationPath(operation: PublicV1OperationDefinition, params?: unknown): string;
+/**
+ * One boolean query flag, parsed once at the public wire boundary.
+ *
+ * A query string carries text, so the flag arrives as text. Both spellings a
+ * caller is likely to send are accepted, and the schema hands the handler a
+ * boolean. Handlers never compare the raw string again: `includeFiltered` used
+ * to be declared as `'0' | '1'` and re-tested as `=== '1'` inside its route,
+ * which is the same value parsed twice under two types.
+ */
+export declare function publicV1BooleanFlag(defaultValue: boolean): z.ZodPipe<z.ZodDefault<z.ZodEnum<{
+    0: "0";
+    1: "1";
+    false: "false";
+    true: "true";
+}>>, z.ZodTransform<boolean, "0" | "1" | "false" | "true">>;
+/** The canonical wire spelling a client sends for {@link publicV1BooleanFlag}. */
+export declare function publicV1BooleanFlagValue(value: boolean): '0' | '1';
 export declare const publicV1ErrorDetailsSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 export declare const publicV1ErrorProducerSchema: z.ZodObject<{
     code: z.ZodEnum<{

package/dist/v1/core.js

@@ -303,6 +303,24 @@ export function buildOperationPath(operation, params) {
         return encodeURIComponent(serialized);
     });
 }
+/**
+ * One boolean query flag, parsed once at the public wire boundary.
+ *
+ * A query string carries text, so the flag arrives as text. Both spellings a
+ * caller is likely to send are accepted, and the schema hands the handler a
+ * boolean. Handlers never compare the raw string again: `includeFiltered` used
+ * to be declared as `'0' | '1'` and re-tested as `=== '1'` inside its route,
+ * which is the same value parsed twice under two types.
+ */
+export function publicV1BooleanFlag(defaultValue) {
+    return z.enum(['0', '1', 'true', 'false'])
+        .default(defaultValue ? '1' : '0')
+        .transform(value => value === '1' || value === 'true');
+}
+/** The canonical wire spelling a client sends for {@link publicV1BooleanFlag}. */
+export function publicV1BooleanFlagValue(value) {
+    return value ? '1' : '0';
+}
 export const publicV1ErrorDetailsSchema = z.record(z.string(), z.unknown());
 export const publicV1ErrorProducerSchema = z.strictObject({
     code: z.enum(PUBLIC_V1_ERROR_CODES),