@nuxtseo/protocol 0.1.0

package/dist/v1/content.js

@@ -0,0 +1,326 @@
+import { z as schema } from 'zod';
+import { defineOperation, defineRegistry, defineResponseObject, defineSuccessEnvelope, publicV1ErrorEnvelope, publicV1StandardRatePolicy, } from './core.js';
+export const contentBriefStatusSchema = schema.enum([
+    'queued',
+    'researching',
+    'ready',
+    'written',
+    'published',
+    'stale',
+    'failed',
+    'archived',
+]);
+export const contentBriefSiteParamsSchema = schema.strictObject({
+    siteId: schema.string().min(1),
+});
+export const contentBriefParamsSchema = schema.strictObject({
+    siteId: schema.string().min(1),
+    briefId: schema.string().min(1),
+});
+export const contentBriefListQuerySchema = schema.strictObject({
+    status: contentBriefStatusSchema.optional(),
+    limit: schema.coerce.number().int().min(1).max(100).default(25),
+    offset: schema.coerce.number().int().nonnegative().default(0),
+});
+export const contentBriefCreateBodySchema = schema.strictObject({
+    keyword: schema.string().min(1).max(200).transform(keyword => keyword.trim()),
+    targetPage: schema.url().optional(),
+    currentRank: schema.number().optional(),
+    currentImpressions: schema.number().int().optional(),
+    currentClicks: schema.number().int().optional(),
+});
+const contentBriefSerpResultShape = {
+    position: schema.number(),
+    url: schema.url(),
+    title: schema.string(),
+    domain: schema.string(),
+    snippet: schema.string().optional(),
+    wordCount: schema.number().int().nonnegative().optional(),
+};
+export const contentBriefSerpResultSchema = defineResponseObject(contentBriefSerpResultShape);
+const contentBriefPaaItemShape = {
+    question: schema.string(),
+    answer: schema.string().optional(),
+};
+export const contentBriefPaaItemSchema = defineResponseObject(contentBriefPaaItemShape);
+const contentBriefSerpSnapshotShape = {
+    fetchedAt: schema.iso.datetime(),
+    topResults: schema.array(contentBriefSerpResultSchema.producer),
+    paa: schema.array(contentBriefPaaItemSchema.producer).optional(),
+    aiOverviewPresent: schema.boolean().optional(),
+    serpFeatures: schema.array(schema.string()).optional(),
+    medianWordCount: schema.number().int().nonnegative().optional(),
+};
+export const contentBriefSerpSnapshotSchema = defineResponseObject(contentBriefSerpSnapshotShape, {
+    ...contentBriefSerpSnapshotShape,
+    topResults: schema.array(contentBriefSerpResultSchema.client),
+    paa: schema.array(contentBriefPaaItemSchema.client).optional(),
+});
+const contentBriefOutlineItemShape = {
+    level: schema.enum(['h1', 'h2', 'h3']),
+    heading: schema.string(),
+    tag: schema.enum(['intent-match', 'your-strength', 'gap', 'from-paa', 'from-aio']).optional(),
+    annotation: schema.string().optional(),
+    wordCountTarget: schema.number().int().nonnegative().optional(),
+    sourceResultUrls: schema.array(schema.url()).optional(),
+    existingCoverageExcerpt: schema.string().optional(),
+    existingCoverageUrl: schema.url().optional(),
+};
+export const contentBriefOutlineItemSchema = defineResponseObject(contentBriefOutlineItemShape);
+const contentBriefInternalLinkShape = {
+    url: schema.url(),
+    impressions: schema.number().int().optional(),
+    position: schema.number().optional(),
+    reasoning: schema.string(),
+    anchorSuggestion: schema.string().optional(),
+    excerpt: schema.string().optional(),
+};
+export const contentBriefInternalLinkSchema = defineResponseObject(contentBriefInternalLinkShape);
+const contentBriefPayloadProducerShape = {
+    targetPage: schema.url().optional(),
+    currentRank: schema.number().optional(),
+    currentImpressions: schema.number().int().optional(),
+    currentClicks: schema.number().int().optional(),
+    serp: contentBriefSerpSnapshotSchema.producer.optional(),
+    outline: schema.array(contentBriefOutlineItemSchema.producer).optional(),
+    internalLinks: schema.array(contentBriefInternalLinkSchema.producer).optional(),
+    summary: schema.string().optional(),
+    notes: schema.array(schema.string()).optional(),
+};
+export const contentBriefPayloadSchema = defineResponseObject(contentBriefPayloadProducerShape, {
+    ...contentBriefPayloadProducerShape,
+    serp: contentBriefSerpSnapshotSchema.client.optional(),
+    outline: schema.array(contentBriefOutlineItemSchema.client).optional(),
+    internalLinks: schema.array(contentBriefInternalLinkSchema.client).optional(),
+});
+const contentBriefSummaryProducerShape = {
+    id: schema.string().min(1),
+    siteId: schema.string().min(1),
+    keyword: schema.string().min(1),
+    status: contentBriefStatusSchema,
+    error: schema.string().nullable(),
+    generatedAt: schema.iso.datetime().nullable(),
+    markedPublishedAt: schema.iso.datetime().nullable(),
+    updatedAt: schema.iso.datetime().nullable(),
+};
+export const contentBriefSummarySchema = defineResponseObject(contentBriefSummaryProducerShape);
+export const contentBriefResourceSchema = defineResponseObject({
+    ...contentBriefSummaryProducerShape,
+    payload: contentBriefPayloadSchema.producer.nullable(),
+    createdAt: schema.iso.datetime().nullable(),
+    markedWrittenAt: schema.iso.datetime().nullable(),
+}, {
+    ...contentBriefSummaryProducerShape,
+    payload: contentBriefPayloadSchema.client.nullable(),
+    createdAt: schema.iso.datetime().nullable(),
+    markedWrittenAt: schema.iso.datetime().nullable(),
+});
+const contentBriefPageShape = {
+    total: schema.number().int().nonnegative(),
+    limit: schema.number().int().positive(),
+    offset: schema.number().int().nonnegative(),
+    hasMore: schema.boolean(),
+};
+const contentBriefPageSchema = defineResponseObject(contentBriefPageShape);
+export const contentBriefListDataSchema = defineResponseObject({
+    briefs: schema.array(contentBriefSummarySchema.producer),
+    page: contentBriefPageSchema.producer,
+}, {
+    briefs: schema.array(contentBriefSummarySchema.client),
+    page: contentBriefPageSchema.client,
+});
+export const contentBriefCreateDataSchema = defineResponseObject({
+    brief: contentBriefResourceSchema.producer,
+    created: schema.boolean(),
+}, {
+    brief: contentBriefResourceSchema.client,
+    created: schema.boolean(),
+});
+export const contentBriefListResponseSchema = defineSuccessEnvelope(contentBriefListDataSchema);
+export const contentBriefShowResponseSchema = defineSuccessEnvelope(contentBriefResourceSchema);
+export const contentBriefCreateResponseSchema = defineSuccessEnvelope(contentBriefCreateDataSchema);
+const readErrors = [
+    'invalid_request',
+    'unauthorized',
+    'auth_expired',
+    'forbidden',
+    'not_found',
+    'rate_limited',
+    'contract_violation',
+    'internal_error',
+];
+export const contentBriefListOperation = defineOperation({
+    id: 'content.briefs.list',
+    method: 'GET',
+    path: '/api/v1/sites/{siteId}/content/briefs',
+    visibility: 'public',
+    semantics: {
+        kind: 'query',
+        sideEffects: 'none',
+        retry: 'idempotent',
+        readConsistency: 'primary',
+    },
+    auth: {
+        credentials: ['session', 'api_token'],
+        scopes: ['content:read'],
+        minimumRole: 'viewer',
+        ownership: 'site',
+    },
+    request: {
+        params: contentBriefSiteParamsSchema,
+        query: contentBriefListQuerySchema,
+        headers: null,
+        body: null,
+    },
+    responses: { 200: contentBriefListResponseSchema },
+    errors: readErrors,
+    errorResponse: publicV1ErrorEnvelope,
+    resources: { reads: [{ type: 'site.content', idFrom: 'params.siteId' }], changes: [] },
+    policy: { rate: publicV1StandardRatePolicy, idempotency: { _tag: 'none' }, entitlement: null, meter: null },
+    lifecycle: { introduced: '1.0.0' },
+    docs: {
+        summary: 'List Content Briefs',
+        description: 'Lists one page of Content Brief summaries owned by a NuxtSEO Site.',
+        tags: ['Content'],
+        examples: [{
+                request: { params: { siteId: 'site_01JXYZ' }, query: { limit: 25, offset: 0 } },
+                response: {
+                    status: 200,
+                    body: {
+                        data: {
+                            briefs: [{
+                                    id: 'brief_01JXYZ',
+                                    siteId: 'site_01JXYZ',
+                                    keyword: 'nuxt seo',
+                                    status: 'ready',
+                                    error: null,
+                                    generatedAt: '2026-08-10T00:00:00.000Z',
+                                    markedPublishedAt: null,
+                                    updatedAt: '2026-08-10T00:00:00.000Z',
+                                }],
+                            page: { total: 1, limit: 25, offset: 0, hasMore: false },
+                        },
+                        meta: { requestId: 'req_01JXYZ', version: '1.0' },
+                    },
+                },
+            }],
+    },
+});
+const exampleBrief = {
+    id: 'brief_01JXYZ',
+    siteId: 'site_01JXYZ',
+    keyword: 'nuxt seo',
+    status: 'ready',
+    error: null,
+    generatedAt: '2026-08-10T00:00:00.000Z',
+    markedPublishedAt: null,
+    updatedAt: '2026-08-10T00:00:00.000Z',
+    createdAt: '2026-08-10T00:00:00.000Z',
+    markedWrittenAt: null,
+    payload: {
+        targetPage: 'https://example.com/guide',
+        outline: [{ level: 'h1', heading: 'Nuxt SEO' }],
+        internalLinks: [],
+    },
+};
+export const contentBriefShowOperation = defineOperation({
+    id: 'content.briefs.show',
+    method: 'GET',
+    path: '/api/v1/sites/{siteId}/content/briefs/{briefId}',
+    visibility: 'public',
+    semantics: {
+        kind: 'query',
+        sideEffects: 'none',
+        retry: 'idempotent',
+        readConsistency: 'primary',
+    },
+    auth: {
+        credentials: ['session', 'api_token'],
+        scopes: ['content:read'],
+        minimumRole: 'viewer',
+        ownership: 'site',
+    },
+    request: { params: contentBriefParamsSchema, query: null, headers: null, body: null },
+    responses: { 200: contentBriefShowResponseSchema },
+    errors: readErrors,
+    errorResponse: publicV1ErrorEnvelope,
+    resources: { reads: [{ type: 'site.content', idFrom: 'params.siteId' }], changes: [] },
+    policy: { rate: publicV1StandardRatePolicy, idempotency: { _tag: 'none' }, entitlement: null, meter: null },
+    lifecycle: { introduced: '1.0.0' },
+    docs: {
+        summary: 'Show a Content Brief',
+        description: 'Returns one Content Brief with its grounded SERP, outline, and internal-link evidence.',
+        tags: ['Content'],
+        examples: [{
+                request: { params: { siteId: 'site_01JXYZ', briefId: 'brief_01JXYZ' } },
+                response: {
+                    status: 200,
+                    body: { data: exampleBrief, meta: { requestId: 'req_01JXYZ', version: '1.0' } },
+                },
+            }],
+    },
+});
+export const contentBriefCreateOperation = defineOperation({
+    id: 'content.briefs.create',
+    method: 'POST',
+    path: '/api/v1/sites/{siteId}/content/briefs',
+    visibility: 'public',
+    semantics: {
+        kind: 'mutation',
+        sideEffects: 'state',
+        retry: 'never',
+        readConsistency: null,
+    },
+    auth: {
+        credentials: ['session', 'api_token'],
+        scopes: ['content:write'],
+        minimumRole: 'member',
+        ownership: 'site',
+    },
+    request: {
+        params: contentBriefSiteParamsSchema,
+        query: null,
+        headers: null,
+        body: contentBriefCreateBodySchema,
+    },
+    responses: { 200: contentBriefCreateResponseSchema },
+    errors: [
+        ...readErrors,
+        'entitlement_required',
+        'conflict',
+        'quota_exhausted',
+    ],
+    errorResponse: publicV1ErrorEnvelope,
+    resources: {
+        reads: [{ type: 'site.content', idFrom: 'params.siteId' }],
+        changes: [{ type: 'site.content', idFrom: 'params.siteId' }],
+    },
+    policy: { rate: publicV1StandardRatePolicy, idempotency: { _tag: 'none' }, entitlement: 'pro', meter: null },
+    lifecycle: { introduced: '1.0.0' },
+    docs: {
+        summary: 'Create a Content Brief',
+        description: 'Creates or returns the existing Site-owned Content Brief for a canonical target keyword.',
+        tags: ['Content'],
+        examples: [{
+                request: {
+                    params: { siteId: 'site_01JXYZ' },
+                    body: { keyword: 'nuxt seo', targetPage: 'https://example.com/guide' },
+                },
+                response: {
+                    status: 200,
+                    body: {
+                        data: { brief: exampleBrief, created: true },
+                        meta: { requestId: 'req_01JXYZ', version: '1.0' },
+                    },
+                },
+            }],
+    },
+});
+export const contentV1Registry = defineRegistry({
+    feature: 'content',
+    operations: {
+        listBriefs: contentBriefListOperation,
+        showBrief: contentBriefShowOperation,
+        createBrief: contentBriefCreateOperation,
+    },
+});

package/dist/v1/core.d.ts

@@ -0,0 +1,301 @@
+import type { ZodRawShape, ZodTypeAny } from 'zod';
+import { z } from 'zod';
+export declare const PUBLIC_V1_VERSION: '1.0';
+export declare const PUBLIC_V1_PATH_PREFIX: '/api/v1';
+export declare const PUBLIC_V1_RESPONSE_HEADERS: {
+    readonly requestId: 'X-Request-Id';
+    readonly version: 'X-NuxtSEO-Version';
+    readonly operation: 'X-NuxtSEO-Operation';
+    readonly rateLimitPolicy: 'RateLimit-Policy';
+    readonly rateLimit: 'RateLimit';
+    readonly retryAfter: 'Retry-After';
+    readonly deprecation: 'Deprecation';
+    readonly sunset: 'Sunset';
+};
+export declare const publicV1StandardRatePolicy: {
+    readonly name: 'public-v1-fixed-window';
+    readonly limit: 50;
+    readonly windowSeconds: 60;
+};
+export declare const PUBLIC_V1_FEATURES: readonly ['account', 'actions', 'analytics', 'audit', 'backlinks', 'content', 'mentions', 'page', 'research', 'sites'];
+export declare const PUBLIC_V1_METHODS: readonly ['DELETE', 'GET', 'PATCH', 'POST'];
+export declare const PUBLIC_V1_CREDENTIALS: readonly ['api_token', 'session'];
+export declare const PUBLIC_V1_SCOPES: readonly ['account:read', 'actions:read', 'actions:write', 'analytics:read', 'audit:read', 'content:read', 'content:write', 'page:read', 'page:write', 'research:read', 'research:write', 'sites:read', 'sites:write'];
+export declare const PUBLIC_V1_ROLES: readonly ['viewer', 'member', 'admin', 'owner'];
+export declare const PUBLIC_V1_ERROR_CODES: readonly ['invalid_request', 'unauthorized', 'forbidden', 'not_found', 'site_ambiguous', 'auth_expired', 'entitlement_required', 'quota_exhausted', 'provider_unavailable', 'stale_evidence', 'conflict', 'rate_limited', 'contract_violation', 'internal_error'];
+export declare const PUBLIC_V1_ERROR_STATUS: {
+    readonly invalid_request: 400;
+    readonly unauthorized: 401;
+    readonly auth_expired: 401;
+    readonly forbidden: 403;
+    readonly entitlement_required: 403;
+    readonly not_found: 404;
+    readonly site_ambiguous: 409;
+    readonly stale_evidence: 409;
+    readonly conflict: 409;
+    readonly quota_exhausted: 429;
+    readonly rate_limited: 429;
+    readonly contract_violation: 500;
+    readonly internal_error: 500;
+    readonly provider_unavailable: 503;
+};
+export type PublicV1Feature = typeof PUBLIC_V1_FEATURES[number];
+export type PublicV1Method = typeof PUBLIC_V1_METHODS[number];
+export type PublicV1Credential = typeof PUBLIC_V1_CREDENTIALS[number];
+export type PublicV1Scope = typeof PUBLIC_V1_SCOPES[number];
+export type PublicV1Role = typeof PUBLIC_V1_ROLES[number];
+export type PublicV1ErrorCode = typeof PUBLIC_V1_ERROR_CODES[number];
+export type PublicV1Visibility = 'internal' | 'public';
+export type PublicV1OwnershipRule = 'principal' | 'site' | 'team';
+export type PublicV1ResourceType = 'account.usage' | 'site.actions' | 'site.analytics' | 'site.audit' | 'site.collection' | 'site.content' | 'site.identity' | 'site.page' | 'site.research' | 'site.sitemaps';
+export interface PublicV1ExpectedFailure {
+    _tag: 'ApiFailure';
+    code: PublicV1ErrorCode;
+    message: string;
+    retryable: boolean;
+    details: Readonly<Record<string, unknown>>;
+}
+export interface CompatibleResponseSchema<TProducer extends ZodTypeAny = ZodTypeAny, TClient extends ZodTypeAny = ZodTypeAny> {
+    producer: TProducer;
+    client: TClient;
+}
+export interface PublicV1RequestSchemas {
+    params: ZodTypeAny | null;
+    query: ZodTypeAny | null;
+    headers: ZodTypeAny | null;
+    body: ZodTypeAny | null;
+}
+export interface PublicV1Semantics {
+    kind: 'mutation' | 'query';
+    sideEffects: 'none' | 'state';
+    retry: 'idempotent' | 'never';
+    readConsistency: 'primary' | 'replica-ok' | null;
+}
+export type PublicV1IdempotencyPolicy = {
+    _tag: 'none';
+} | {
+    _tag: 'required';
+    header: 'Idempotency-Key';
+    retentionSeconds: number;
+};
+export interface PublicV1RatePolicy {
+    name: string;
+    limit: number;
+    windowSeconds: number;
+}
+export interface PublicV1ResourceReference {
+    type: PublicV1ResourceType;
+    idFrom: `params.${string}` | 'principal.id' | 'team.id';
+}
+export interface PublicV1OperationExample {
+    request: {
+        params?: unknown;
+        query?: unknown;
+        headers?: unknown;
+        body?: unknown;
+    };
+    response: {
+        status: number;
+        body: unknown;
+    };
+}
+export interface PublicV1OperationDefinition {
+    id: `${PublicV1Feature}.${string}`;
+    method: PublicV1Method;
+    path: `/api/v1/${string}`;
+    visibility: PublicV1Visibility;
+    semantics: PublicV1Semantics;
+    auth: {
+        credentials: readonly PublicV1Credential[];
+        scopes: readonly PublicV1Scope[];
+        minimumRole: PublicV1Role;
+        ownership: PublicV1OwnershipRule;
+    };
+    request: PublicV1RequestSchemas;
+    responses: Readonly<Record<number, CompatibleResponseSchema>>;
+    errors: readonly PublicV1ErrorCode[];
+    errorResponse: CompatibleResponseSchema;
+    resources: {
+        reads: readonly PublicV1ResourceReference[];
+        changes: readonly PublicV1ResourceReference[];
+    };
+    policy: {
+        rate: PublicV1RatePolicy;
+        idempotency: PublicV1IdempotencyPolicy;
+        entitlement: string | null;
+        meter: {
+            key: string;
+            units: number;
+            charge: 'always' | 'live-only';
+        } | null;
+    };
+    lifecycle: {
+        introduced: `${number}.${number}.${number}`;
+        deprecated?: {
+            version: `${number}.${number}.${number}`;
+            at: string;
+        };
+        sunset?: string;
+    };
+    docs: {
+        summary: string;
+        description: string;
+        tags: readonly string[];
+        examples: readonly PublicV1OperationExample[];
+    };
+}
+export interface PublicV1Registry<TOperations extends Readonly<Record<string, PublicV1OperationDefinition>> = Readonly<Record<string, PublicV1OperationDefinition>>> {
+    feature: PublicV1Feature;
+    operations: TOperations;
+}
+export interface PublicV1ProtocolLike {
+    version: typeof PUBLIC_V1_VERSION;
+    registries: Readonly<Record<string, PublicV1Registry>>;
+    schemas: {
+        errorEnvelope: CompatibleResponseSchema;
+    };
+}
+type PublicV1ProtocolRegistry<TProtocol extends PublicV1ProtocolLike> = TProtocol['registries'][keyof TProtocol['registries']];
+type PublicV1RegistryOperation<TRegistry> = TRegistry extends PublicV1Registry<infer TOperations> ? TOperations[keyof TOperations] : never;
+export type PublicV1ProtocolOperation<TProtocol extends PublicV1ProtocolLike> = PublicV1RegistryOperation<PublicV1ProtocolRegistry<TProtocol>>;
+export type PublicV1OperationEntry<TProtocol extends PublicV1ProtocolLike = PublicV1ProtocolLike> = PublicV1ProtocolRegistry<TProtocol> extends infer TRegistry ? TRegistry extends PublicV1Registry ? {
+    registry: TRegistry;
+    operation: PublicV1RegistryOperation<TRegistry>;
+} : never : never;
+export declare function defineOperation<const TOperation extends PublicV1OperationDefinition>(operation: TOperation): TOperation;
+export declare function defineRegistry<const TOperations extends Readonly<Record<string, PublicV1OperationDefinition>>>(registry: PublicV1Registry<TOperations>): PublicV1Registry<TOperations>;
+export declare function defineProtocol<const TRegistries extends Readonly<Record<string, PublicV1Registry>>>(protocol: Omit<PublicV1ProtocolLike, 'registries'> & {
+    registries: TRegistries;
+}): Omit<PublicV1ProtocolLike, 'registries'> & {
+    registries: TRegistries;
+};
+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;
+export declare const publicV1ErrorDetailsSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+export declare const publicV1ErrorProducerSchema: 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>;
+export declare const publicV1ErrorClientSchema: 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>;
+export declare const publicV1ErrorEnvelope: 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>>;
+export declare const publicV1MetaProducerSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    version: z.ZodLiteral<"1.0">;
+}, z.core.$strict>;
+export declare const publicV1MetaClientSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    version: z.ZodLiteral<"1.0">;
+}, z.core.$loose>;
+export declare function defineSuccessEnvelope<const TProducer extends ZodTypeAny, const TClient extends ZodTypeAny, const TMetaProducer extends ZodTypeAny = typeof publicV1MetaProducerSchema, const TMetaClient extends ZodTypeAny = typeof publicV1MetaClientSchema>(data: CompatibleResponseSchema<TProducer, TClient>, meta?: CompatibleResponseSchema<TMetaProducer, TMetaClient>): CompatibleResponseSchema<z.ZodObject<{
+    data: TProducer;
+    meta: TMetaProducer;
+}>, z.ZodObject<{
+    data: TClient;
+    meta: TMetaClient;
+}>>;
+export type OperationInput<TOperation extends PublicV1OperationDefinition> = (TOperation['request']['params'] extends ZodTypeAny ? {
+    params: z.input<TOperation['request']['params']>;
+} : {
+    params?: never;
+}) & (TOperation['request']['query'] extends ZodTypeAny ? {
+    query: z.input<TOperation['request']['query']>;
+} : {
+    query?: never;
+}) & (TOperation['request']['headers'] extends ZodTypeAny ? {
+    headers: z.input<TOperation['request']['headers']>;
+} : {
+    headers?: never;
+}) & (TOperation['request']['body'] extends ZodTypeAny ? {
+    body: z.input<TOperation['request']['body']>;
+} : {
+    body?: never;
+});
+type OperationResponseSchema<TOperation extends PublicV1OperationDefinition> = TOperation['responses'][keyof TOperation['responses']] extends CompatibleResponseSchema<ZodTypeAny, infer TClient> ? TClient : never;
+export type OperationOutput<TOperation extends PublicV1OperationDefinition> = z.output<OperationResponseSchema<TOperation>>;
+export {};