@orthacms/content-server 0.4.3 → 0.5.0

package/dist/lib/docs/openapi-writer.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The two writes every `decorate` pass in this package makes on the generated
+ * document, and the one rule they both follow: **never invent a status code.**
+ *
+ * The scanner has already emitted whichever 2xx key the handler actually
+ * answers with — 201 for a bare `@Post`, 200 elsewhere, and whatever a
+ * `@HttpCode` moved it to — so a schema is written *onto that key* rather than
+ * onto a guessed one. A document that describes a `200` for a route answering
+ * `201` is worse than a document that describes nothing, because a consumer
+ * cannot tell it is wrong without curling the API, which is the whole thing
+ * these passes exist to make unnecessary.
+ */
+import type { OpenApiSchema } from './field-schema';
+/** An operation object, as far as these passes need to see one. */
+export interface Operation {
+    parameters?: {
+        name: string;
+        in: string;
+        schema?: OpenApiSchema;
+        description?: string;
+    }[];
+    responses?: Record<string, {
+        description?: string;
+        content?: unknown;
+    }>;
+}
+/**
+ * Writes a success response's schema onto whichever 2xx key the scanner already
+ * emitted.
+ *
+ * `204` is left alone deliberately: a no-content response has no body, and
+ * attaching one would describe a payload the server never sends.
+ */
+export declare function setSuccessResponse(operation: Operation, schema: OpenApiSchema, description: string, 
+/**
+ * Media type. `application/json` for all but the two transfer downloads,
+ * which stream a file.
+ */
+mediaType?: string, 
+/** Response headers worth documenting, keyed by header name. */
+headers?: Record<string, unknown>): void;
+/**
+ * Writes a success response carrying several media types — one download route
+ * whose content type depends on what the caller asked for.
+ */
+export declare function setSuccessResponseVariants(operation: Operation, byMediaType: Record<string, OpenApiSchema>, description: string, headers?: Record<string, unknown>): void;
+/** Adds a documented failure response, leaving any existing one alone. */
+export declare function addErrorResponse(operation: Operation, code: string, description: string, schema?: OpenApiSchema): void;
+//# sourceMappingURL=openapi-writer.d.ts.map

package/dist/lib/docs/openapi-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi-writer.d.ts","sourceRoot":"","sources":["../../../src/lib/docs/openapi-writer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAEpD,mEAAmE;AACnE,MAAM,WAAW,SAAS;IACtB,UAAU,CAAC,EAAE;QACT,IAAI,EAAE,MAAM,CAAC;QACb,EAAE,EAAE,MAAM,CAAC;QACX,MAAM,CAAC,EAAE,aAAa,CAAC;QACvB,WAAW,CAAC,EAAE,MAAM,CAAC;KACxB,EAAE,CAAC;IACJ,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;CAC3E;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAC9B,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,aAAa,EACrB,WAAW,EAAE,MAAM;AACnB;;;GAGG;AACH,SAAS,SAAqB;AAC9B,gEAAgE;AAChE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAClC,IAAI,CAYN;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CACtC,SAAS,EAAE,SAAS,EACpB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,EAC1C,WAAW,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAClC,IAAI,CAiBN;AAED,0EAA0E;AAC1E,wBAAgB,gBAAgB,CAC5B,SAAS,EAAE,SAAS,EACpB,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EACnB,MAAM,CAAC,EAAE,aAAa,GACvB,IAAI,CAUN"}

package/dist/lib/docs/openapi-writer.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * The two writes every `decorate` pass in this package makes on the generated
+ * document, and the one rule they both follow: **never invent a status code.**
+ *
+ * The scanner has already emitted whichever 2xx key the handler actually
+ * answers with — 201 for a bare `@Post`, 200 elsewhere, and whatever a
+ * `@HttpCode` moved it to — so a schema is written *onto that key* rather than
+ * onto a guessed one. A document that describes a `200` for a route answering
+ * `201` is worse than a document that describes nothing, because a consumer
+ * cannot tell it is wrong without curling the API, which is the whole thing
+ * these passes exist to make unnecessary.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setSuccessResponse = setSuccessResponse;
+exports.setSuccessResponseVariants = setSuccessResponseVariants;
+exports.addErrorResponse = addErrorResponse;
+/**
+ * Writes a success response's schema onto whichever 2xx key the scanner already
+ * emitted.
+ *
+ * `204` is left alone deliberately: a no-content response has no body, and
+ * attaching one would describe a payload the server never sends.
+ */
+function setSuccessResponse(operation, schema, description, 
+/**
+ * Media type. `application/json` for all but the two transfer downloads,
+ * which stream a file.
+ */
+mediaType = 'application/json', 
+/** Response headers worth documenting, keyed by header name. */
+headers) {
+    const responses = operation.responses ?? {};
+    const key = Object.keys(responses).find((code) => /^2\d\d$/.test(code));
+    if (!key || key === '204') {
+        return;
+    }
+    responses[key] = {
+        description,
+        ...(headers ? { headers } : {}),
+        content: { [mediaType]: { schema } }
+    };
+    operation.responses = responses;
+}
+/**
+ * Writes a success response carrying several media types — one download route
+ * whose content type depends on what the caller asked for.
+ */
+function setSuccessResponseVariants(operation, byMediaType, description, headers) {
+    const responses = operation.responses ?? {};
+    const key = Object.keys(responses).find((code) => /^2\d\d$/.test(code));
+    if (!key || key === '204') {
+        return;
+    }
+    responses[key] = {
+        description,
+        ...(headers ? { headers } : {}),
+        content: Object.fromEntries(Object.entries(byMediaType).map(([type, schema]) => [
+            type,
+            { schema }
+        ]))
+    };
+    operation.responses = responses;
+}
+/** Adds a documented failure response, leaving any existing one alone. */
+function addErrorResponse(operation, code, description, schema) {
+    const responses = operation.responses ?? {};
+    if (responses[code]) {
+        return;
+    }
+    responses[code] = {
+        description,
+        ...(schema ? { content: { 'application/json': { schema } } } : {})
+    };
+    operation.responses = responses;
+}

package/dist/lib/docs/public-api-schemas.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The OpenAPI schemas of the **public** content API (`/api/v1/...`), kept apart
+ * from the admin's for the same reason `types/public-entry.ts` is kept apart
+ * from `EntryRecord`: this is a published contract an external site builds
+ * against, and it must be free to stay still while the admin's shape moves.
+ *
+ * Splitting them is not tidiness. Until this module existed the document
+ * described `/api/v1/content/{typeName}/{id}` with the **admin** entry schema,
+ * because the route pattern in `describe-content-api.ts` matched both spellings
+ * — so a consumer reading the reference was told a relation preview carries
+ * `RelationRef`s (id + title) when the public API returns whole entries, and
+ * that a media read is `Record<string, MediaRef[]>` when it is
+ * `Record<string, { items, total }>`. A wrong schema is worse than an absent
+ * one: the absent one sends you to curl, the wrong one does not.
+ */
+import type { SerializedContentType } from '../registry/content-type-registry';
+import { type OpenApiSchema } from './field-schema';
+/** Schema names of one content type's public trio. */
+export interface PublicTypeSchemaNames {
+    /** The `values` bag — the entry's own data, references omitted. */
+    values: string;
+    /** One entry as the public API serves it. */
+    entry: string;
+    /** One page of them. */
+    listPage: string;
+}
+/** The three schema names a content type contributes to the public document. */
+export declare function publicSchemaNamesOf(type: SerializedContentType): PublicTypeSchemaNames;
+/**
+ * The public per-type entry schemas as alternatives — the response shape
+ * depends on `typeName`, which OpenAPI cannot express as a dependency. One
+ * registered type needs no union; none at all leaves an open object, since
+ * every one of these routes 404s anyway.
+ *
+ * `anyOf` rather than `oneOf`, for the reason `unionOf` in
+ * `describe-content-api.ts` spells out: the alternatives overlap, and *exactly
+ * one* is a promise the API does not keep.
+ */
+export declare function publicUnionOf(names: string[]): OpenApiSchema;
+/**
+ * Every schema the public API contributes: its fixed shapes plus, per
+ * registered content type, the `Values` / `Entry` / `ListPage` trio.
+ */
+export declare function buildPublicApiSchemas(types: readonly SerializedContentType[]): Record<string, OpenApiSchema>;
+//# sourceMappingURL=public-api-schemas.d.ts.map

package/dist/lib/docs/public-api-schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public-api-schemas.d.ts","sourceRoot":"","sources":["../../../src/lib/docs/public-api-schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mCAAmC,CAAC;AAG/E,OAAO,EAAe,KAAK,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAMjE,sDAAsD;AACtD,MAAM,WAAW,qBAAqB;IAClC,mEAAmE;IACnE,MAAM,EAAE,MAAM,CAAC;IACf,6CAA6C;IAC7C,KAAK,EAAE,MAAM,CAAC;IACd,wBAAwB;IACxB,QAAQ,EAAE,MAAM,CAAC;CACpB;AAED,gFAAgF;AAChF,wBAAgB,mBAAmB,CAC/B,IAAI,EAAE,qBAAqB,GAC5B,qBAAqB,CAOvB;AA+JD;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,aAAa,CAK5D;AAuMD;;;GAGG;AACH,wBAAgB,qBAAqB,CACjC,KAAK,EAAE,SAAS,qBAAqB,EAAE,GACxC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAY/B"}

package/dist/lib/docs/public-api-schemas.js

@@ -0,0 +1,377 @@
+"use strict";
+/**
+ * The OpenAPI schemas of the **public** content API (`/api/v1/...`), kept apart
+ * from the admin's for the same reason `types/public-entry.ts` is kept apart
+ * from `EntryRecord`: this is a published contract an external site builds
+ * against, and it must be free to stay still while the admin's shape moves.
+ *
+ * Splitting them is not tidiness. Until this module existed the document
+ * described `/api/v1/content/{typeName}/{id}` with the **admin** entry schema,
+ * because the route pattern in `describe-content-api.ts` matched both spellings
+ * — so a consumer reading the reference was told a relation preview carries
+ * `RelationRef`s (id + title) when the public API returns whole entries, and
+ * that a media read is `Record<string, MediaRef[]>` when it is
+ * `Record<string, { items, total }>`. A wrong schema is worse than an absent
+ * one: the absent one sends you to curl, the wrong one does not.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publicSchemaNamesOf = publicSchemaNamesOf;
+exports.publicUnionOf = publicUnionOf;
+exports.buildPublicApiSchemas = buildPublicApiSchemas;
+const fields_1 = require("../types/fields");
+const content_type_1 = require("../types/content-type");
+const field_schema_1 = require("./field-schema");
+const content_schemas_1 = require("./content-schemas");
+const UUID = { type: 'string', format: 'uuid' };
+const DATE_TIME = { type: 'string', format: 'date-time' };
+/** The three schema names a content type contributes to the public document. */
+function publicSchemaNamesOf(type) {
+    const base = `Public${(0, content_schemas_1.pascalCase)(type.name)}`;
+    return {
+        values: `${base}Values`,
+        entry: `${base}Entry`,
+        listPage: `${base}ListPage`
+    };
+}
+/**
+ * Whether a field's value appears in a public entry's `values` bag.
+ *
+ * Mirrors `public-api/infrastructure/public-entry-row.ts`'s
+ * `isPureValueField` — **every** reference kind is dropped, `relation` in all
+ * four cardinalities and `media` alike, because the public read resolves
+ * neither in `values` and a bare uuid is an identifier with nothing to follow.
+ * Deliberately stricter than the admin's `isValueField`, which keeps an owning
+ * single relation's FK.
+ */
+function isPublicValueField(field) {
+    return (field.type !== fields_1.CONTENT_FIELD_TYPE.Relation &&
+        field.type !== fields_1.CONTENT_FIELD_TYPE.Media);
+}
+/** The `values` bag of one content type, as the public API serves it. */
+function publicValuesSchema(type) {
+    const fields = type.fields.filter(isPublicValueField);
+    const omitted = type.fields
+        .filter((field) => !isPublicValueField(field))
+        .map((field) => field.name);
+    const properties = {};
+    for (const field of fields) {
+        properties[field.name] = (0, field_schema_1.fieldSchema)(field);
+    }
+    const notes = [
+        `Field values keyed by field name, for one \`${type.name}\` entry.`,
+        'An unset field reads back as `null`, never as a missing key — except under a `?fields=` sparse fieldset, where only the requested keys are present at all.',
+        omitted.length
+            ? `Reference fields (${omitted
+                .map((name) => `\`${name}\``)
+                .join(', ')}) are **not** in this bag: read relations through \`?relations=preview\` or the \`/relations/{field}\` route, and media through \`?media=preview\` or \`/media\`. The schema endpoint still describes them, because they are part of the real model.`
+            : ''
+    ].filter(Boolean);
+    return {
+        type: 'object',
+        title: `${type.label} values (public)`,
+        description: notes.join(' '),
+        properties,
+        // No `required`: a sparse fieldset may narrow the bag to one key, and a
+        // publishable type's "required" fields are required to publish rather
+        // than to exist.
+        additionalProperties: false
+    };
+}
+/** One entry of a content type, as the public API serves it. */
+function publicEntrySchema(type, names) {
+    const properties = {
+        id: { ...UUID, description: 'Entry id.' },
+        ...(type.publishable
+            ? {
+                status: {
+                    type: 'string',
+                    enum: Object.values(content_type_1.ENTRY_STATUS),
+                    description: 'Publish state. A read-only token only ever sees `published`; a write-scoped one can create a draft and read it back with `?status=`.'
+                },
+                publishedAt: {
+                    ...DATE_TIME,
+                    nullable: true,
+                    description: 'When this entry last went live. `draft` together with a non-null `publishedAt` is live content carrying unpublished edits — neither field alone tells those apart.'
+                }
+            }
+            : {}),
+        createdAt: DATE_TIME,
+        updatedAt: DATE_TIME,
+        ...(type.i18n
+            ? {
+                locale: {
+                    type: 'string',
+                    description: 'Locale slug of this row.'
+                },
+                localeGroupId: {
+                    ...UUID,
+                    description: 'Translation group — this row’s siblings in other locales share it, and it is the id the `/group/{localeGroupId}` routes take.'
+                }
+            }
+            : {}),
+        values: (0, content_schemas_1.ref)(names.values),
+        relations: {
+            type: 'object',
+            additionalProperties: (0, content_schemas_1.ref)('PublicRelationFieldPage'),
+            description: 'Relation links keyed by field name — present only with `?relations=preview`. Each linked record is a whole entry, not a ref.'
+        },
+        media: {
+            type: 'object',
+            additionalProperties: (0, content_schemas_1.ref)('PublicMediaFieldPage'),
+            description: 'Media assets keyed by field name — present only with `?media=preview`.'
+        },
+        ...(type.i18n
+            ? {
+                translations: {
+                    type: 'array',
+                    items: (0, content_schemas_1.ref)(names.entry),
+                    description: 'The entry’s **other** published locale rows — present only with `?translations=preview`. The entry itself is not repeated, and the siblings are not themselves expanded.'
+                }
+            }
+            : {})
+    };
+    return {
+        type: 'object',
+        title: `${type.label} (public)`,
+        description: `One \`${type.name}\` entry on the public API.`,
+        properties,
+        required: [
+            'id',
+            'createdAt',
+            'updatedAt',
+            'values',
+            ...(type.publishable ? ['status', 'publishedAt'] : []),
+            ...(type.i18n ? ['locale', 'localeGroupId'] : [])
+        ]
+    };
+}
+/** One page of public entries of a content type. */
+function publicListPageSchema(type, names) {
+    return {
+        type: 'object',
+        title: `${type.label} page (public)`,
+        description: `One page of \`${type.name}\` entries. \`total\` counts every match, ignoring pagination.`,
+        properties: {
+            items: { type: 'array', items: (0, content_schemas_1.ref)(names.entry) },
+            total: { type: 'integer' },
+            page: {
+                type: 'integer',
+                description: '1-based page number this page represents.'
+            },
+            pageSize: {
+                type: 'integer',
+                description: 'Rows per page actually applied.'
+            }
+        },
+        required: ['items', 'total', 'page', 'pageSize']
+    };
+}
+/**
+ * The public per-type entry schemas as alternatives — the response shape
+ * depends on `typeName`, which OpenAPI cannot express as a dependency. One
+ * registered type needs no union; none at all leaves an open object, since
+ * every one of these routes 404s anyway.
+ *
+ * `anyOf` rather than `oneOf`, for the reason `unionOf` in
+ * `describe-content-api.ts` spells out: the alternatives overlap, and *exactly
+ * one* is a promise the API does not keep.
+ */
+function publicUnionOf(names) {
+    if (!names.length)
+        return { type: 'object', additionalProperties: true };
+    return names.length === 1
+        ? (0, content_schemas_1.ref)(names[0])
+        : { anyOf: names.map((name) => (0, content_schemas_1.ref)(name)) };
+}
+/**
+ * The public API's fixed shapes — the ones that do not vary by content type,
+ * except where an entry appears inside them.
+ *
+ * `entryUnion` is threaded in rather than referenced by name because a relation
+ * page and a translation list carry whole entries, and which entries those are
+ * is the registry's answer, not this module's.
+ */
+function publicSharedSchemas(entryUnion) {
+    return {
+        PublicMediaTrack: {
+            type: 'object',
+            description: 'One timed-text track on a published video or audio asset — everything a `<track>` element needs.',
+            properties: {
+                kind: {
+                    type: 'string',
+                    description: '`captions` / `subtitles` / `descriptions` / `chapters`.'
+                },
+                srclang: {
+                    type: 'string',
+                    description: 'BCP-47 tag of the track’s language.'
+                },
+                label: {
+                    type: 'string',
+                    description: 'What a player shows in its track menu.'
+                },
+                src: {
+                    type: 'string',
+                    description: 'Route the WebVTT bytes stream from — same bearer token as the read.'
+                },
+                default: {
+                    type: 'boolean',
+                    description: 'Whether a player should enable this track by default.'
+                }
+            },
+            required: ['kind', 'srclang', 'label', 'src']
+        },
+        PublicMediaRef: {
+            type: 'object',
+            description: 'One attached asset. The URLs take the **same bearer token** as the read that produced them, so a server-side consumer can fetch the bytes with the credential it already holds — but a browser `<img src>` sends no `Authorization` header and will not load one. Proxy them from whatever holds the token.',
+            properties: {
+                id: UUID,
+                name: {
+                    type: 'string',
+                    description: 'Display name — the original file name.'
+                },
+                url: {
+                    type: 'string',
+                    description: 'Route the original bytes stream from.'
+                },
+                thumbUrl: {
+                    type: 'string',
+                    description: '~320px derivative, when one was generated (absent for non-images, SVGs, and images too small to derive).'
+                },
+                previewUrl: {
+                    type: 'string',
+                    description: '~1280px derivative, same caveats.'
+                },
+                kind: {
+                    type: 'string',
+                    description: 'Coarse kind — image / video / audio / document / archive.'
+                },
+                mimeType: { type: 'string' },
+                alt: {
+                    type: 'string',
+                    nullable: true,
+                    description: 'The text alternative for **this usage**. `""` and `null` mean different things: `""` is “render `alt=""`, this image says nothing”, `null` is “nobody supplied one” — a gap to report, not an instruction to hide the image from assistive tech.'
+                },
+                decorative: {
+                    type: 'boolean',
+                    enum: [true],
+                    description: 'Present, and always `true`, when the author marked this usage purely presentational.'
+                },
+                tracks: {
+                    type: 'array',
+                    items: (0, content_schemas_1.ref)('PublicMediaTrack'),
+                    description: 'Empty for an image, and for a video nobody has captioned.'
+                }
+            },
+            required: ['id', 'name', 'url', 'kind', 'mimeType', 'alt', 'tracks']
+        },
+        PublicMediaFieldPage: {
+            type: 'object',
+            description: 'One media field’s assets, in their stored order.',
+            properties: {
+                items: { type: 'array', items: (0, content_schemas_1.ref)('PublicMediaRef') },
+                total: {
+                    type: 'integer',
+                    description: 'Assets attached to this field.'
+                }
+            },
+            required: ['items', 'total']
+        },
+        PublicEntryMedia: {
+            type: 'object',
+            description: 'Every media field of the entry, keyed by field name.',
+            properties: {
+                media: {
+                    type: 'object',
+                    additionalProperties: (0, content_schemas_1.ref)('PublicMediaFieldPage')
+                }
+            },
+            required: ['media']
+        },
+        PublicRelationFieldPage: {
+            type: 'object',
+            description: 'One relation field’s links: a capped page plus the true total. Each item is a **whole entry**, envelope and `values` alike — not a ref — so a consumer renders a linked record with the code it already has. Linked entries are not themselves expanded. A target the caller may not see is omitted **and not counted**, so `total` is the number of links actually reachable.',
+            properties: {
+                items: { type: 'array', items: entryUnion },
+                total: {
+                    type: 'integer',
+                    description: 'Visible links for this field, ignoring the page cap.'
+                }
+            },
+            required: ['items', 'total']
+        },
+        PublicEntryTranslations: {
+            type: 'object',
+            description: 'The entry’s other published locale rows, ordered by locale slug. The entry itself is not repeated, and a locale that exists only as a draft is absent.',
+            properties: {
+                translations: { type: 'array', items: entryUnion }
+            },
+            required: ['translations']
+        },
+        PublicContentTypeList: {
+            type: 'object',
+            description: 'Every content type granted to the requested workspace — exactly the set of `typeName`s that will not 404.',
+            properties: {
+                items: { type: 'array', items: (0, content_schemas_1.ref)('ContentTypeSummary') }
+            },
+            required: ['items']
+        },
+        PublicBulkError: {
+            type: 'object',
+            description: 'Why one item of a batch did not go through, carrying **the status the same write would have failed with on its own** (404, 422, 400) rather than a bulk-specific vocabulary.',
+            properties: {
+                status: { type: 'integer' },
+                message: { type: 'string' },
+                issues: {
+                    type: 'array',
+                    items: (0, content_schemas_1.ref)('ValidationIssue'),
+                    description: 'The per-field issues of a 422.'
+                }
+            },
+            required: ['status', 'message']
+        },
+        PublicBulkSaveItemResult: {
+            type: 'object',
+            description: 'What became of one submitted item, positionally matched to the request.',
+            properties: {
+                index: {
+                    type: 'integer',
+                    description: '0-based position in the submitted `items`.'
+                },
+                op: { type: 'string', enum: ['create', 'update'] },
+                ok: { type: 'boolean' },
+                entry: entryUnion,
+                error: (0, content_schemas_1.ref)('PublicBulkError')
+            },
+            required: ['index', 'op', 'ok']
+        },
+        PublicBulkSaveResult: {
+            type: 'object',
+            description: '**Partial success is the contract**, not a degraded mode: items are written one transaction at a time, so the call is a 200 with per-item verdicts whether or not every item saved, and a caller retries the failures it can fix.',
+            properties: {
+                items: {
+                    type: 'array',
+                    items: (0, content_schemas_1.ref)('PublicBulkSaveItemResult')
+                },
+                created: { type: 'integer' },
+                updated: { type: 'integer' },
+                failed: { type: 'integer' }
+            },
+            required: ['items', 'created', 'updated', 'failed']
+        }
+    };
+}
+/**
+ * Every schema the public API contributes: its fixed shapes plus, per
+ * registered content type, the `Values` / `Entry` / `ListPage` trio.
+ */
+function buildPublicApiSchemas(types) {
+    const entryUnion = publicUnionOf(types.map((type) => publicSchemaNamesOf(type).entry));
+    const schemas = publicSharedSchemas(entryUnion);
+    for (const type of types) {
+        const names = publicSchemaNamesOf(type);
+        schemas[names.values] = publicValuesSchema(type);
+        schemas[names.entry] = publicEntrySchema(type, names);
+        schemas[names.listPage] = publicListPageSchema(type, names);
+    }
+    return schemas;
+}

package/dist/lib/docs/views-schemas.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The OpenAPI schemas the **saved views** plugin contributes.
+ *
+ * `SavedView` is a plain TypeScript `interface` in `views/domain/`, which the
+ * swagger scanner cannot see and ADR-0003 forbids decorating — so the shape is
+ * written out here instead, the same way the content types are.
+ *
+ * One thing about it is runtime data rather than a fixed contract: `scope` is
+ * `content:<typeName>`, and which type names exist is what the host registered.
+ * {@link buildViewsSchemas} therefore takes the serialized registry and turns
+ * the scope into an enum of the real lists, so a reader of the reference sees
+ * `content:article`, not "some string".
+ */
+import type { SerializedContentType } from '../registry/content-type-registry';
+import type { OpenApiSchema } from './field-schema';
+/** Schema name of one saved view. */
+export declare const SAVED_VIEW_SCHEMA = "SavedView";
+/** Schema name of the slice a view restores. */
+export declare const SAVED_VIEW_PAYLOAD_SCHEMA = "SavedViewPayload";
+/** The saved-view schemas, keyed by schema name. */
+export declare function buildViewsSchemas(types: readonly SerializedContentType[]): Record<string, OpenApiSchema>;
+//# sourceMappingURL=views-schemas.d.ts.map

package/dist/lib/docs/views-schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"views-schemas.d.ts","sourceRoot":"","sources":["../../../src/lib/docs/views-schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mCAAmC,CAAC;AAC/E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAepD,qCAAqC;AACrC,eAAO,MAAM,iBAAiB,cAAc,CAAC;AAC7C,gDAAgD;AAChD,eAAO,MAAM,yBAAyB,qBAAqB,CAAC;AA8I5D,oDAAoD;AACpD,wBAAgB,iBAAiB,CAC7B,KAAK,EAAE,SAAS,qBAAqB,EAAE,GACxC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAK/B"}