@forumulate/sdk 0.4.0 → 0.7.0

package/README.md

@@ -39,13 +39,74 @@ The [CLI](https://www.npmjs.com/package/@forumulate/cli) and the [MCP server](ht
 const { user } = await forumulate.auth.me();
 const { orgs } = await forumulate.orgs.list();
 const orgId = orgs[0]!.id; // ids and slugs are both accepted wherever an org id is
-const { spaces } = await forumulate.spaces.list(orgId);
-console.log(
-  user.email,
-  spaces.map((s) => `${s.slug} [${s.type}]`),
-);
+
+// Every list is an async iterator over every row, across every page.
+for await (const space of forumulate.spaces.list({ orgId })) {
+  console.log(space.slug, space.type);
+}
+```
+
+## Every operation is a method
+
+Each of the API's ~1,800 operations is a method named after its operationId:
+`ForumTopics_get` is `forumulate.forum.topics.get`, `Webhook_rotate` is
+`forumulate.webhooks.rotate`. Paths, query, body and response are typed from
+the OpenAPI spec, and the namespaces are generated from it, so a route in the
+[API reference](https://forumulate.com/reference) is a method here.
+
+```ts
+// One argument: path params at the top level, `query` and `body` nested.
+const { space } = await forumulate.spaces.get({ orgId, spaceId });
+await forumulate.blog.create({ orgId, spaceId, body: { title: 'v2 is out', content } });
+await forumulate.webhooks.update({ orgId, webhookId, body: { active: false } });
+await forumulate.webhooks.delete({ orgId, webhookId }); // `delete` aliases the API's `remove`
+await forumulate.tokens.rotate({ id: patId });
+await forumulate.forum.taxonomy.listCategories({ orgId, spaceId }); // a sub-namespace per area of a namespace
 ```
 
+| Area                     | Namespaces                                                                                                                |
+| ------------------------ | ------------------------------------------------------------------------------------------------------------------------- |
+| Organization             | `orgs`, `spaces`, `sites`, `members`, `invites`, `roles`, `grants`, `groups`, `tokens`, `users`, `billing`, `sso`, `scim` |
+| Docs                     | `items`, `pages`, `collections`, `shapes`, `snapshots`, `changeRequests`, `docs`, `openapi`, `comments`                   |
+| Community and publishing | `blog`, `forum`, `community`, `moderation`, `chat`, `messages`, `changelog`, `roadmap`, `newsletter`                      |
+| Space types              | `status`, `events`, `courses`, `faq`, `careers`, `legal`, `forms`, `questions`                                            |
+| Platform                 | `webhooks`, `domains`, `themes`, `extensions`, `integrations`, `notifications`, `mail`, `assets`, `embeds`, `privacy`     |
+| Search, AI and analytics | `search`, `ai`, `analytics`                                                                                               |
+| Headless CMS             | `content` (libraries, entries, model, locales, keys, assets…), `delivery`                                                 |
+| Public reader (no token) | `public`, and the `public…` sub-namespace of each area: `forum.publicTopic`, `status.public`, `blog.public`…              |
+
+`method.operationId` tells you which operation a method calls. By id, with the same types:
+
+```ts
+const { space } = await forumulate.request('Space_get', { orgId, spaceId });
+for await (const hook of forumulate.paginate('Webhook_list', { orgId })) console.log(hook.url);
+```
+
+The 0.5 positional helpers (`spaces.list(orgId)`, `items.create(orgId, spaceId, input)`…) still work
+unchanged, except `auth.register` and `auth.login`, removed in 0.6: their routes went away when
+sign-in moved to Atlas, so they failed for every caller. Authenticate with a Personal Access Token. Where one shares a name with a generated method it is the same operation, and the member
+takes either call shape.
+
+### Pagination
+
+A list returns a `PagePromise`: `await` it for the first page as the API answered it, `for await` it for every row.
+
+```ts
+const first = await forumulate.blog.list({ orgId, spaceId, query: { limit: 50 } });
+first.page.nextCursor; // the envelope: page.{limit, hasMore, nextCursor, total}, rows under data
+
+for await (const post of forumulate.blog.list({ orgId, spaceId })) {
+  /* every post */
+}
+for await (const page of forumulate.blog.list({ orgId, spaceId }).pages()) {
+  /* every page */
+}
+```
+
+The walk follows `page.nextCursor`, and `?page=` for the ranked lists that have no cursor. The
+generated methods send `Forumulate-Version` (the version the SDK was generated at, `API_VERSION`,
+unless you set `apiVersion`) because only a versioned answer carries the envelope.
+
 ## Common tasks
 
 ### 1. Write and publish a page from markdown
@@ -104,9 +165,10 @@ await forumulate.forum.reply(orgId, forumSpaceId, topicId, doc('Upgrade notes ar
 ### 5. Verify a webhook
 
 ```ts
-import { verifyWebhookSignature } from '@forumulate/sdk';
+import { constructWebhookEvent } from '@forumulate/sdk';
 
-const ok = await verifyWebhookSignature({
+// Verifies the signature and its timestamp, THEN parses; throws if either fails.
+const event = await constructWebhookEvent({
   secret: process.env.FORUMULATE_WEBHOOK_SECRET!,
   body: rawBody, // the exact bytes received, before JSON.parse
   signature: req.headers['x-forumulate-signature'] as string,
@@ -114,7 +176,21 @@ const ok = await verifyWebhookSignature({
 });
 ```
 
-Create the webhook with `forumulate.webhooks.create(orgId, { url, events })`.
+`verifyWebhookSignature` (also `forumulate.webhooks.verifySignature`) is the same check returning a
+boolean. Create the endpoint with `forumulate.webhooks.create({ orgId, body: { url, events } })`;
+`webhooks.rotate`, `webhooks.ping`, `webhooks.deliveries` and `webhooks.replay` manage it after.
+
+### 6. Translations, any kind of piece
+
+`client.translations` picks the right route from the space's type: a docs page's language twin, a post's, topic's or release's translation, or an incident's. You only name the original piece and the language. Machine translation uses your organization's own DeepL key or AI provider. See [Translations everywhere](https://forumulate.com/guides/translations-everywhere).
+
+```ts
+const cov = await client.translations.status(orgId, spaceId); // piece × language → missing/draft/published/outdated
+await client.translations.locales.set(orgId, { spaceId }, [{ code: 'es', label: 'Español' }]);
+await client.translations.auto(orgId, spaceId, pageId, 'es');
+const es = await client.translations.get(orgId, spaceId, pageId, 'es'); // { title, markdown, state }
+await client.translations.put(orgId, spaceId, pageId, 'es', { markdown: '…', published: true });
+```
 
 ## Every endpoint: `typed()`
 
@@ -134,23 +210,43 @@ await forumulate.typed('post', '/orgs/{orgId}/spaces', {
 
 Pass `raw: true` for the untouched `Response` (binary downloads). For anything else, `request(method, path, { body, query, headers })` is the untyped escape hatch that `typed` and the helpers use.
 
+Operations that answer a file (PDF, PNG, ZIP) or a stream resolve to the `Response`; text answers (CSV, Markdown, iCal) resolve to a `string`.
+
 ## Errors
 
-Every non-2xx response throws a `ForumulateError` carrying `status`, `code` and `message` from the API's error envelope.
+Every non-2xx response throws a `ForumulateError` carrying the API's error envelope: `status`, `code`,
+`message`, `details` (field-level, for `validation.failed`), `requestId` (quote it in a support request)
+and `retryAfter` (seconds, when the API said).
 
 ```ts
 import { ForumulateError } from '@forumulate/sdk';
 
 try {
-  await forumulate.orgs.create({ name: '', slug: '' });
+  await forumulate.orgs.create({ body: { name: '', slug: '' } });
 } catch (err) {
   if (err instanceof ForumulateError && err.code === 'validation.failed') {
-    /* … */
+    console.log(err.details); // { name: ['Required'], … }
   }
 }
 ```
 
-A `401` means the token is missing or revoked. A `403` means it lacks a scope or capability; see [API tokens and scopes](https://forumulate.com/guides/api-tokens-and-scopes).
+A `401` means the token is missing or revoked. A `403` means it lacks a scope or capability; see [API tokens and scopes](https://forumulate.com/guides/api-tokens-and-scopes). A network failure that outlives its retries is a `ForumulateError` with `status: 0` and `code: 'network.error'`.
+
+## Retries and idempotency
+
+Requests that are safe to repeat are retried on `408`, `429`, `502`, `503`, `504` and network
+failures: two retries by default, waiting what `Retry-After` says (a wait over a minute is surfaced
+rather than slept through), else exponential backoff with jitter. A `500` is not retried.
+
+Every POST and PATCH carries an `Idempotency-Key`, generated once per call and reused by its
+retries, so a write that timed out is retried without running twice. Pass your own to dedupe
+across processes:
+
+```ts
+await forumulate.items.create({ orgId, spaceId, body, idempotencyKey: message.id });
+```
+
+Each call also takes `headers`, `signal` (an `AbortSignal`) and `maxRetries`.
 
 ## Options
 
@@ -158,13 +254,20 @@ A `401` means the token is missing or revoked. A `403` means it lacks a scope or
 new ForumulateClient({
   baseUrl: 'https://forumulate.com/api',
   token,
-  headers: { 'Forumulate-Version': '2026-09-01' }, // pin the API version for this client
+  apiVersion: '2026-12-01', // Forumulate-Version for every request (default: generated methods only)
+  maxRetries: 2, // 0 turns retries off
+  autoIdempotencyKey: true, // generated Idempotency-Key on POST/PATCH
+  userAgent: 'my-app/1.0', // default forumulate-sdk-js/<version> outside a browser
+  headers: { 'X-Trace': id }, // sent on every request
   fetch: customFetch, // any fetch-compatible function
   credentials: true, // browser on the same origin: send the session cookie instead of a token
 });
 ```
 
-Set a descriptive `User-Agent` when you run outside a browser: the edge firewall challenges default library User-Agents.
+The default `User-Agent` matters outside a browser: the edge firewall challenges default library User-Agents.
+
+The package has no runtime dependencies and is marked side-effect free; the route table behind the
+namespaces is about 100 KB unminified (about 20 KB gzipped) and namespaces are built on first use.
 
 ## Links
 
@@ -179,9 +282,15 @@ Set a descriptive `User-Agent` when you run outside a browser: the edge firewall
 
 ```sh
 curl -s https://forumulate.com/api/openapi.json -o packages/sdk/openapi.json
-pnpm --filter @forumulate/sdk generate-schema   # → src/schema.ts
+pnpm --filter @forumulate/sdk generate-schema   # → src/schema.ts, then src/operations.gen.ts
 ```
 
+`src/operations.gen.ts` is the route table behind the namespaces (`generate-operations` rebuilds it
+alone). Placement lives in `scripts/generate-operations.mjs`: a short map from operationId tag
+prefixes to namespaces, so a new tag lands somewhere without an edit. `src/coverage.test.ts` fails
+when the table is stale, when an operation has no method, or when a 0.5 helper and a generated
+method share a name but not an operation.
+
 ## License
 
 MIT

package/dist/content.d.ts

@@ -0,0 +1,318 @@
+/**
+ * Content libraries (headless CMS): the management routes under
+ * `/orgs/{orgId}/content/libraries/{libraryId}/…`.
+ *
+ * Hand-written because the generated `schema.ts` is refreshed from the
+ * DEPLOYED spec, and these routes are newer than the last refresh; `typed()`
+ * covers them once it catches up. Everything is addressed by `libraryId`,
+ * never by the hidden space behind a library: that id is not part of the
+ * contract (spec 14).
+ */
+type Request = <T>(method: string, path: string, opts?: {
+    body?: unknown;
+    query?: Record<string, string | number | boolean | undefined>;
+    headers?: Record<string, string>;
+}) => Promise<T>;
+export interface ContentLibrary {
+    id: string;
+    name: string;
+    slug: string;
+    siteId: string | null;
+    settings: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+}
+export type LibraryRole = 'viewer' | 'editor' | 'manager';
+export interface LibraryMember {
+    userId: string;
+    email: string;
+    name: string;
+    role: LibraryRole | null;
+    customRoleId: string | null;
+    effect: 'ALLOW' | 'DENY';
+}
+/** A declared model change a diff cannot infer (a rename), or a removal. */
+export type ModelOp = {
+    op: 'renameField';
+    type?: string;
+    blockType?: string;
+    from: string;
+    to: string;
+} | {
+    op: 'removeField';
+    type?: string;
+    blockType?: string;
+    path: string;
+} | {
+    op: 'restoreField';
+    type?: string;
+    blockType?: string;
+    path: string;
+} | {
+    op: 'renameType';
+    from: string;
+    to: string;
+} | {
+    op: 'renameBlockType';
+    from: string;
+    to: string;
+};
+export interface ContentModel {
+    shape: Record<string, unknown>;
+    types: Record<string, unknown>;
+    version: number;
+}
+export interface ContentModelVersion {
+    version: number;
+    ops: ModelOp[];
+    createdBy: string | null;
+    createdAt: string;
+    migratedAt: string | null;
+}
+export type ModelFileFormat = 'json' | 'payload';
+export interface ModelFileIssue {
+    path: string;
+    kind: 'hook' | 'access' | 'component' | 'function' | 'lossy' | 'unsupported' | 'ignored' | 'rewritten';
+    message: string;
+}
+export interface ContentModelExport {
+    format: ModelFileFormat;
+    filename: string;
+    content: string;
+    version: number;
+    issues: ModelFileIssue[];
+}
+export interface ModelChangeLine {
+    op: 'add' | 'remove' | 'change';
+    target: 'type' | 'setting' | 'field' | 'blockType' | 'blockField';
+    type?: string;
+    blockType?: string;
+    path?: string;
+    property?: string;
+    before?: unknown;
+    after?: unknown;
+}
+export interface ContentModelImportResult {
+    changed: boolean;
+    applied: boolean;
+    diff: ModelChangeLine[];
+    storageOnly: boolean;
+    ops: ModelOp[];
+    issues: ModelFileIssue[];
+    version: number;
+}
+/** An entry as the management API answers a write: enough to address it again. */
+export interface ContentEntryRef {
+    id: string;
+    title: string;
+    slug?: string;
+    preset?: string | null;
+}
+export interface ContentAssetSummary {
+    id: string;
+    url: string;
+    filename: string;
+    contentType?: string;
+    [extra: string]: unknown;
+}
+export type DeliveryKeyKind = 'delivery' | 'publishable' | 'preview';
+export interface DeliveryKeySummary {
+    id: string;
+    name: string;
+    kind: DeliveryKeyKind;
+    prefix: string;
+    stage: 'published' | 'draft';
+    libraryId: string;
+    origins: string[] | null;
+    contentTypes: string[] | null;
+    locales: string[] | null;
+    lastUsedAt: string | null;
+    [extra: string]: unknown;
+}
+export interface IssuedDeliveryKey {
+    key: DeliveryKeySummary;
+    /** Shown once. */
+    secret: string;
+}
+export declare function contentApi(request: Request): {
+    libraries: {
+        list: (orgId: string) => Promise<{
+            libraries: ContentLibrary[];
+        }>;
+        get: (orgId: string, libraryId: string) => Promise<{
+            library: ContentLibrary;
+        }>;
+        create: (orgId: string, input: {
+            name: string;
+            slug?: string;
+            siteId?: string | null;
+            settings?: Record<string, unknown>;
+            template?: string;
+        }) => Promise<{
+            library: ContentLibrary;
+        }>;
+        update: (orgId: string, libraryId: string, input: {
+            name?: string;
+            slug?: string;
+            siteId?: string | null;
+            settings?: Record<string, unknown>;
+        }) => Promise<{
+            library: ContentLibrary;
+        }>;
+        remove: (orgId: string, libraryId: string) => Promise<{
+            ok: true;
+        }>;
+    };
+    members: {
+        list: (orgId: string, libraryId: string) => Promise<{
+            members: LibraryMember[];
+        }>;
+        put: (orgId: string, libraryId: string, input: {
+            userId: string;
+            role?: LibraryRole;
+            customRoleId?: string;
+            effect?: "ALLOW" | "DENY";
+        }) => Promise<{
+            member: LibraryMember;
+        }>;
+        remove: (orgId: string, libraryId: string, userId: string) => Promise<{
+            ok: true;
+        }>;
+    };
+    model: {
+        get: (orgId: string, libraryId: string) => Promise<{
+            model: ContentModel;
+        }>;
+        save: (orgId: string, libraryId: string, input: {
+            shape?: Record<string, unknown>;
+            types?: Record<string, unknown>;
+            ops?: ModelOp[];
+        }) => Promise<{
+            model: ContentModel;
+        }>;
+        versions: (orgId: string, libraryId: string) => Promise<{
+            versions: ContentModelVersion[];
+        }>;
+        /** The model as a file: `forumulate.content.json`, or a Payload config. */
+        export: (orgId: string, libraryId: string, format?: ModelFileFormat) => Promise<ContentModelExport>;
+        /** Push a model file: a diff always, a new version unless `dryRun` (or nothing changed). */
+        import: (orgId: string, libraryId: string, input: {
+            format: ModelFileFormat;
+            content: string;
+            dryRun?: boolean;
+            baseVersion?: number;
+            force?: boolean;
+            ops?: ModelOp[];
+        }) => Promise<ContentModelImportResult>;
+        /** The library's delivery JSON Schema (what `forumulate content types` generates from). */
+        schema: (orgId: string, libraryId: string, opts?: {
+            audience?: "public" | "preview";
+        }) => Promise<Record<string, unknown>>;
+    };
+    /**
+     * Entries by their management id. `create` takes an `Idempotency-Key` (the
+     * route requires one), so a retried import returns the entry the first call
+     * made. Later writes may carry the entry's `contentHash` as `If-Match`; an import is the only writer, so it sends none.
+     */
+    entries: {
+        create: (orgId: string, libraryId: string, input: {
+            title: string;
+            slug?: string;
+            preset: string;
+            params?: Record<string, unknown>;
+        }, idempotencyKey: string) => Promise<{
+            item: ContentEntryRef;
+            warnings?: string[];
+        }>;
+        /** Which of these `Idempotency-Key`s already made an entry, as key → entry id (an import's dry-run and its update path). */
+        lookup: (orgId: string, libraryId: string, keys: string[]) => Promise<{
+            found: Record<string, string>;
+        }>;
+        /** Rename, re-address or patch the fields (`params`) of an entry. */
+        update: (orgId: string, libraryId: string, entryId: string, input: {
+            title?: string;
+            slug?: string;
+            params?: Record<string, unknown>;
+        }) => Promise<{
+            item: ContentEntryRef;
+            warnings?: string[];
+        }>;
+        /** Write an entry's localized fields into the DRAFT of one locale's twin, making the twin first when needed. */
+        writeLocale: (orgId: string, libraryId: string, entryId: string, locale: string, fields: Record<string, unknown>) => Promise<{
+            locale: string;
+            sourceEntryId: string;
+            entryId: string;
+            created: boolean;
+        }>;
+        read: (orgId: string, libraryId: string, entryId: string) => Promise<{
+            item: ContentEntryRef & {
+                contentHash: string;
+            };
+        }>;
+        setFields: (orgId: string, libraryId: string, entryId: string, fields: Record<string, unknown>, ifMatch?: string) => Promise<{
+            fields: Record<string, unknown>;
+            warnings?: string[];
+        }>;
+        publish: (orgId: string, libraryId: string, entryId: string, ifMatch?: string) => Promise<{
+            published: boolean;
+            note?: string;
+        }>;
+    };
+    locales: {
+        list: (orgId: string, libraryId: string) => Promise<{
+            sourceLocale: string;
+            locales: {
+                code: string;
+                label: string;
+            }[];
+        }>;
+        add: (orgId: string, libraryId: string, input: {
+            code: string;
+            label: string;
+        }) => Promise<{
+            sourceLocale: string;
+            locales: {
+                code: string;
+                label: string;
+            }[];
+        }>;
+    };
+    assets: {
+        list: (orgId: string, libraryId: string, query?: {
+            search?: string;
+            limit?: number;
+        }) => Promise<{
+            assets: ContentAssetSummary[];
+        }>;
+    };
+    keys: {
+        list: (orgId: string, libraryId: string) => Promise<{
+            keys: DeliveryKeySummary[];
+        }>;
+        create: (orgId: string, libraryId: string, input: {
+            name: string;
+            kind: DeliveryKeyKind;
+            origins?: string[];
+            contentTypes?: string[];
+            locales?: string[];
+            expiresInDays?: number;
+        }) => Promise<IssuedDeliveryKey>;
+        update: (orgId: string, libraryId: string, keyId: string, input: {
+            name?: string;
+            origins?: string[] | null;
+            contentTypes?: string[] | null;
+            locales?: string[] | null;
+        }) => Promise<{
+            key: DeliveryKeySummary;
+        }>;
+        rotate: (orgId: string, libraryId: string, keyId: string, input?: {
+            graceMinutes?: number;
+        }) => Promise<IssuedDeliveryKey>;
+        revoke: (orgId: string, libraryId: string, keyId: string) => Promise<{
+            ok: true;
+        }>;
+    };
+};
+export type ContentApi = ReturnType<typeof contentApi>;
+export {};
+//# sourceMappingURL=content.d.ts.map

package/dist/content.js

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * Content libraries (headless CMS): the management routes under
+ * `/orgs/{orgId}/content/libraries/{libraryId}/…`.
+ *
+ * Hand-written because the generated `schema.ts` is refreshed from the
+ * DEPLOYED spec, and these routes are newer than the last refresh; `typed()`
+ * covers them once it catches up. Everything is addressed by `libraryId`,
+ * never by the hidden space behind a library: that id is not part of the
+ * contract (spec 14).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contentApi = contentApi;
+function contentApi(request) {
+    const lib = (orgId, libraryId) => `/orgs/${orgId}/content/libraries/${libraryId}`;
+    return {
+        libraries: {
+            list: (orgId) => request('GET', `/orgs/${orgId}/content/libraries`),
+            get: (orgId, libraryId) => request('GET', lib(orgId, libraryId)),
+            create: (orgId, input) => request('POST', `/orgs/${orgId}/content/libraries`, { body: input }),
+            update: (orgId, libraryId, input) => request('PATCH', lib(orgId, libraryId), { body: input }),
+            remove: (orgId, libraryId) => request('DELETE', lib(orgId, libraryId)),
+        },
+        members: {
+            list: (orgId, libraryId) => request('GET', `${lib(orgId, libraryId)}/members`),
+            put: (orgId, libraryId, input) => request('POST', `${lib(orgId, libraryId)}/members`, { body: input }),
+            remove: (orgId, libraryId, userId) => request('DELETE', `${lib(orgId, libraryId)}/members/${userId}`),
+        },
+        model: {
+            get: (orgId, libraryId) => request('GET', `${lib(orgId, libraryId)}/model`),
+            save: (orgId, libraryId, input) => request('PUT', `${lib(orgId, libraryId)}/model`, { body: input }),
+            versions: (orgId, libraryId) => request('GET', `${lib(orgId, libraryId)}/model/versions`),
+            /** The model as a file: `forumulate.content.json`, or a Payload config. */
+            export: (orgId, libraryId, format = 'json') => request('GET', `${lib(orgId, libraryId)}/model/export`, { query: { format } }),
+            /** Push a model file: a diff always, a new version unless `dryRun` (or nothing changed). */
+            import: (orgId, libraryId, input) => request('POST', `${lib(orgId, libraryId)}/model/import`, { body: input }),
+            /** The library's delivery JSON Schema (what `forumulate content types` generates from). */
+            schema: (orgId, libraryId, opts = {}) => request('GET', `${lib(orgId, libraryId)}/model/schema.json`, { query: { audience: opts.audience } }),
+        },
+        /**
+         * Entries by their management id. `create` takes an `Idempotency-Key` (the
+         * route requires one), so a retried import returns the entry the first call
+         * made. Later writes may carry the entry's `contentHash` as `If-Match`; an import is the only writer, so it sends none.
+         */
+        entries: {
+            create: (orgId, libraryId, input, idempotencyKey) => request('POST', `${lib(orgId, libraryId)}/items`, {
+                body: input,
+                headers: { 'Idempotency-Key': idempotencyKey },
+            }),
+            /** Which of these `Idempotency-Key`s already made an entry, as key → entry id (an import's dry-run and its update path). */
+            lookup: (orgId, libraryId, keys) => request('POST', `${lib(orgId, libraryId)}/items/lookup`, { body: { keys } }),
+            /** Rename, re-address or patch the fields (`params`) of an entry. */
+            update: (orgId, libraryId, entryId, input) => request('PATCH', `${lib(orgId, libraryId)}/items/${entryId}`, { body: input }),
+            /** Write an entry's localized fields into the DRAFT of one locale's twin, making the twin first when needed. */
+            writeLocale: (orgId, libraryId, entryId, locale, fields) => request('PUT', `${lib(orgId, libraryId)}/entries/${entryId}/locales/${encodeURIComponent(locale)}`, { body: { fields } }),
+            read: (orgId, libraryId, entryId) => request('GET', `${lib(orgId, libraryId)}/items/${entryId}`),
+            setFields: (orgId, libraryId, entryId, fields, ifMatch) => request('PATCH', `${lib(orgId, libraryId)}/items/${entryId}/fields`, {
+                body: { fields },
+                headers: ifMatch ? { 'If-Match': `"${ifMatch}"` } : undefined,
+            }),
+            publish: (orgId, libraryId, entryId, ifMatch) => request('POST', `${lib(orgId, libraryId)}/items/${entryId}/publish`, {
+                headers: ifMatch ? { 'If-Match': `"${ifMatch}"` } : undefined,
+            }),
+        },
+        locales: {
+            list: (orgId, libraryId) => request('GET', `${lib(orgId, libraryId)}/locales`),
+            add: (orgId, libraryId, input) => request('POST', `${lib(orgId, libraryId)}/locales`, { body: input }),
+        },
+        assets: {
+            list: (orgId, libraryId, query = {}) => request('GET', `${lib(orgId, libraryId)}/assets`, { query }),
+        },
+        keys: {
+            list: (orgId, libraryId) => request('GET', `${lib(orgId, libraryId)}/keys`),
+            create: (orgId, libraryId, input) => request('POST', `${lib(orgId, libraryId)}/keys`, { body: input }),
+            update: (orgId, libraryId, keyId, input) => request('PATCH', `${lib(orgId, libraryId)}/keys/${keyId}`, { body: input }),
+            rotate: (orgId, libraryId, keyId, input = {}) => request('POST', `${lib(orgId, libraryId)}/keys/${keyId}/rotate`, { body: input }),
+            revoke: (orgId, libraryId, keyId) => request('DELETE', `${lib(orgId, libraryId)}/keys/${keyId}`),
+        },
+    };
+}
+//# sourceMappingURL=content.js.map