@nohead/sdk 0.0.0 → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog
+
+Changes to `@nohead/sdk` that you can notice. Versions follow
+[Semantic Versioning](https://semver.org): additive API changes are minor
+releases; a change that could break your code is a major one. Each release's
+section is its GitHub release's notes.
+
+## 0.1.0
+
+The first release.
+
+- `new Nohead()`, with methods for every operation an API key can call:
+  records (with revisions, scheduling, bulk changes and search), collections,
+  fields and migrations, assets, webhooks and their deliveries, the audit
+  log, feature flags.
+- Lists you can `await` for one page or `for await` across every page.
+- Typed errors per API error type, retries with idempotency keys, `ifMatch`
+  and change notes, `withResponse()`.
+- `assets.upload()` in one call, and webhook verification
+  (`webhooks.unwrap()`, or `@nohead/sdk/webhooks` without a client).

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nohead
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,5 +1,354 @@
-# @nohead/sdk
+# Nohead TypeScript SDK
 
-Placeholder for the official TypeScript SDK for the Nohead API. The first real release is 0.1.0.
+The official TypeScript client for the [Nohead](https://nohead.io) API: typed records, pagination you can loop over, retries that are safe for writes, one-call uploads and webhook verification. No runtime dependencies.
 
-This is a placeholder release that holds the name. Nohead is a headless CMS: see [nohead.io](https://nohead.io).
+```ts
+import { Nohead } from "@nohead/sdk"
+
+const nohead = new Nohead() // reads NOHEAD_API_KEY
+
+for await (const post of nohead.records.list("posts", {
+  filter: { status: "published" },
+})) {
+  console.log(post.data.title)
+}
+```
+
+> **Status:** 0.x, not yet published to npm. Until it is, install from GitHub: `npm install github:nohead-io/nohead-typescript`.
+
+## Contents
+
+- [Installation](#installation)
+- [Configuration](#configuration)
+- [Records](#records)
+- [Pagination](#pagination)
+- [Errors](#errors)
+- [Retries and idempotency](#retries-and-idempotency)
+- [Concurrency](#concurrency)
+- [Assets](#assets)
+- [Search](#search)
+- [Schema](#schema)
+- [Webhooks](#webhooks)
+- [Raw responses](#raw-responses)
+- [Reference](#reference)
+- [Development](#development)
+
+## Installation
+
+```bash
+npm install @nohead/sdk
+```
+
+The package is ESM; Node 22+ can also `require()` it. It runs on Node 22, 24 and 26, Bun, Deno, Cloudflare Workers and other runtimes with `fetch` and Web Crypto. Use it on servers: API keys are secrets.
+
+## Configuration
+
+```ts
+const nohead = new Nohead({
+  apiKey: process.env.NOHEAD_API_KEY, // default: NOHEAD_API_KEY
+  baseUrl: "https://api.nohead.io", // default: NOHEAD_API_URL, else production
+})
+```
+
+| Option       | Default                                        |                                                      |
+| ------------ | ---------------------------------------------- | ---------------------------------------------------- |
+| `apiKey`     | `NOHEAD_API_KEY`                               | A project API key (`sk_live_…`). Required.           |
+| `baseUrl`    | `NOHEAD_API_URL`, else `https://api.nohead.io` |                                                      |
+| `projectId`  | the key's project                              | Looked up once with `GET /v1/me` when omitted.       |
+| `maxRetries` | `2`                                            | See [retries](#retries-and-idempotency).             |
+| `timeout`    | `60000`                                        | Milliseconds per attempt.                            |
+| `fetch`      | `globalThis.fetch`                             | For proxies, instrumentation and tests.              |
+| `headers`    | `{}`                                           | Added to every request.                              |
+| `warnings`   | `true`                                         | Logs deprecation and plan usage warnings, once each. |
+
+API keys belong to a project, so methods like `collections.list()` need no project ID. Collections can be named by ID or slug everywhere.
+
+## Records
+
+```ts
+const draft = await nohead.records.create("posts", {
+  data: { title: "Hello", author: "rec_01J9…" },
+})
+const post = await nohead.records.get(draft.id, { expand: ["author"] })
+await nohead.records.update(post.id, { data: { title: "Hello again" } })
+await nohead.records.publish(post.id)
+await nohead.records.schedule(post.id, { unpublish_at: new Date("2027-01-01") })
+await nohead.records.delete(post.id) // soft delete; records.restore() undoes it
+```
+
+Methods return the resource and throw on failure. Field names stay as the API sends them (`published_at`, `data`), so the API reference applies as-is.
+
+**Typed data.** Describe a collection's fields and pass the type:
+
+```ts
+interface Post {
+  title: string
+  author: string
+}
+
+const post = await nohead.records.get<Post>(id) // post.data.title: string
+await nohead.records.update<Post>(id, { data: { title: null } }) // null clears
+```
+
+The type is a promise you make; nothing is checked at runtime. The record type itself is `Nohead.Record<Post>` (also exported as `NoheadRecord`).
+
+**More:** `count`, `bulk` (up to 100 records at once), `diff`, `revisions.list`, `revisions.get` and `revisions.revert` (with `{ dry_run: true }` for a preview).
+
+## Pagination
+
+List methods return a promise of the first page that you can also loop over:
+
+```ts
+// Every record, fetching pages as needed
+for await (const record of nohead.records.list("posts")) { … }
+
+// One page at a time
+let page = await nohead.records.list("posts", { limit: 100 })
+page.data // this page's records
+page.meta // { next_cursor, has_more }
+while (page.hasNextPage()) page = await page.getNextPage()
+
+// Resume from a saved cursor
+await nohead.records.list("posts", { cursor: page.meta.next_cursor! })
+```
+
+Filters are equality filters (for fields with several values: "contains"), and accept strings, numbers, booleans and dates:
+
+```ts
+nohead.records.list("posts", {
+  filter: { status: "published", featured: true, author: "rec_01J9…" },
+  sort: "-published_at",
+  expand: ["author", "tags"],
+})
+```
+
+## Errors
+
+Every error is a `NoheadError`. API errors are `APIError`s with `status`, `type`, `message`, `requestId`, `details` and `headers`, in a class per type:
+
+| Class                     | Status                  |
+| ------------------------- | ----------------------- |
+| `InvalidRequestError`     | 400                     |
+| `AuthenticationError`     | 401                     |
+| `PlanLimitExceededError`  | 402                     |
+| `AuthorizationError`      | 403                     |
+| `NotFoundError`           | 404                     |
+| `ConflictError`           | 409                     |
+| `PreconditionFailedError` | 412 (`currentRevision`) |
+| `ValidationError`         | 422                     |
+| `RateLimitError`          | 429 (`retryAfter`)      |
+| `InternalServerError`     | 500 and other 5xx       |
+| `ServiceUnavailableError` | 503                     |
+
+Other errors: `ConnectionError`, `TimeoutError` (a `ConnectionError`), `AbortError` (your `signal` fired), `UploadError` and `WebhookVerificationError`.
+
+```ts
+import { ValidationError } from "@nohead/sdk"
+
+try {
+  await nohead.records.create("posts", { data: {} })
+} catch (error) {
+  if (error instanceof ValidationError) {
+    console.log(error.details) // [{ field: "title", code: "required", message: "…" }]
+  } else {
+    throw error
+  }
+}
+```
+
+## Retries and idempotency
+
+Failed requests are retried twice by default (`maxRetries`), with exponential backoff:
+
+- what's retried: connection errors, timeouts, 429, 500, 502, 503, 504, and a 409 for a request that is still running
+- `Retry-After` is honored up to 60 seconds; a longer one throws `RateLimitError` straight away
+
+Every write gets an `Idempotency-Key` that stays the same across its retries, so a retry after a lost response never writes twice. To make a write safe across your own retries (a job that may run twice), pass a key:
+
+```ts
+await nohead.records.create(
+  "posts",
+  { data },
+  { idempotencyKey: `import-${row.id}` }
+)
+```
+
+Every method takes request options as its last argument:
+
+- `idempotencyKey`
+- `ifMatch` (record writes)
+- `changeNote`, a reason shown in history
+- `signal`, `timeout`, `maxRetries` and `headers`
+
+## Concurrency
+
+Pass the revision you read to make sure nobody changed the record since:
+
+```ts
+const post = await nohead.records.get(id)
+try {
+  await nohead.records.update(id, { data: { title } }, { ifMatch: post })
+} catch (error) {
+  if (error instanceof PreconditionFailedError) {
+    // changed since: reload, and merge or ask
+  }
+}
+```
+
+`ifMatch` takes a record or a revision number, on `update`, `delete`, `publish`, `unpublish` and `revisions.revert`.
+
+## Assets
+
+```ts
+import { openAsBlob } from "node:fs"
+
+const asset = await nohead.assets.upload(await openAsBlob("cover.jpg"), {
+  filename: "cover.jpg",
+})
+await nohead.records.update(id, { data: { cover: asset.id } })
+
+const { url } = await nohead.assets.imageUrl(asset.id, {
+  width: 1200,
+  format: "webp",
+})
+```
+
+**What `upload` accepts:** a `Blob`, `File`, `ArrayBuffer`, `Uint8Array`, or a `ReadableStream` with `byte_size`.
+
+**What it does:**
+
+1. Creates the upload.
+2. Sends the bytes straight to storage.
+3. Completes the upload, which checks the file, and returns the `ready` asset.
+
+**Errors:** `UploadError` if storage refuses the bytes; `ValidationError` if the file fails the checks.
+
+**Uploading from a browser:** create the upload on your server with `createUpload`, `PUT` the file from the browser, then `complete` it.
+
+## Search
+
+```ts
+// One collection
+for await (const hit of nohead.records.search("posts", "content model")) { … }
+
+// Across the project
+const results = await nohead.search("content model", { collections: ["posts", "pages"] })
+results.meta.total_estimate
+```
+
+Search needs `search_enabled` collections and the `search:read` scope. It pages through the first 1,000 hits.
+
+## Schema
+
+```ts
+const posts = await nohead.collections.create({
+  name: "Posts",
+  slug: "posts",
+  fields: [{ name: "Title", api_key: "title", type: "text", required: true }],
+})
+await nohead.fields.create("posts", {
+  name: "Summary",
+  api_key: "summary",
+  type: "long_text",
+})
+
+// Changes that rewrite records go through a migration; preview first
+const preview = await nohead.fields.migrate("fld_…", {
+  type: "long_text",
+  dry_run: true,
+})
+const migration = await nohead.fields.migrate("fld_…", { type: "long_text" })
+await nohead.migrations.get(migration.id)
+```
+
+For schema as code, see the `nohead` CLI (`nohead schema pull/diff/push`).
+
+## Webhooks
+
+Verify a webhook request, then use its event:
+
+```ts
+// e.g. a Next.js route handler
+export async function POST(request: Request) {
+  const event = await nohead.webhooks.unwrap(
+    await request.text(),
+    request.headers,
+    {
+      secret: process.env.NOHEAD_WEBHOOK_SECRET!,
+    }
+  )
+  if (event.type === "record.published") {
+    revalidateTag(event.data.record.collection)
+  }
+  return new Response(null, { status: 204 })
+}
+```
+
+`unwrap` checks the signature and the timestamp (Standard Webhooks), and throws `WebhookVerificationError` if either is off. Pass the raw body: parsing and re-serializing JSON changes the bytes.
+
+A receiver that never calls the API can use `unwrapWebhook` from `@nohead/sdk/webhooks` without a client. Events can arrive more than once, so deduplicate by the `webhook-id` header.
+
+## Raw responses
+
+```ts
+const { data, response, requestId } = await nohead.records
+  .get(id)
+  .withResponse()
+response.headers.get("RateLimit-Remaining")
+```
+
+## Reference
+
+| Resource                    | Methods                                                                                                                                     |
+| --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| `records`                   | `list`, `get`, `create`, `update`, `delete`, `restore`, `publish`, `unpublish`, `schedule`, `unschedule`, `count`, `bulk`, `diff`, `search` |
+| `records.revisions`         | `list`, `get`, `revert`                                                                                                                     |
+| `search`                    | across the project                                                                                                                          |
+| `collections`               | `list`, `get`, `create`, `update`, `delete`, `restore`, `schema`                                                                            |
+| `collections.schemaChanges` | `list`, `get`                                                                                                                               |
+| `collections.searchIndex`   | `get`, `rebuild`                                                                                                                            |
+| `fields`                    | `list`, `create`, `update`, `delete`, `restore`, `reorder`, `removeAlias`, `migrate`                                                        |
+| `migrations`                | `list`, `get`, `cancel`                                                                                                                     |
+| `assets`                    | `upload`, `createUpload`, `complete`, `list`, `get`, `delete`, `restore`, `imageUrl`, `downloadUrl`                                         |
+| `webhooks`                  | `list`, `get`, `create`, `update`, `delete`, `rotateSecret`, `test`, `unwrap`                                                               |
+| `webhooks.deliveries`       | `list`, `get`, `retry`                                                                                                                      |
+| `auditEvents`               | `list`                                                                                                                                      |
+| `featureFlags`              | `list`                                                                                                                                      |
+| `me`                        | `get`                                                                                                                                       |
+| `health`                    | `check`                                                                                                                                     |
+
+The SDK covers every operation an API key can call. Organizations, projects, members and API keys are managed in the web app. The full API is documented at [docs.nohead.io](https://docs.nohead.io).
+
+## Development
+
+```bash
+npm install          # also builds dist/
+npm test             # unit and contract tests
+npm run lint && npm run typecheck && npm run format:check
+npm run generate     # after updating openapi.json
+npm run samples      # after changing test/calls.ts (the docs' code samples)
+NOHEAD_API_URL=http://localhost:3000 NOHEAD_API_KEY=sk_live_… npm run smoke
+```
+
+**How the code is organized:**
+
+- `openapi.json` is the API's published contract. `npm run generate` derives two things from it:
+  - the types, in `src/generated/types.gen.ts` (hey-api)
+  - the operation table, in `src/generated/operations.gen.ts`
+- The methods in `src/resources` are written by hand.
+- `test/contract.test.ts` calls every public method. It fails when an API-key operation in the contract has no method, or when a request doesn't match its operation.
+
+The smoke test (`smoke/smoke.ts`) runs the core flow against a real API, using the built package. Nohead's own CI runs it on every API contract change.
+
+## Releasing
+
+1. Bump the version in `package.json` and `src/version.ts`.
+2. Add a section for it to `CHANGELOG.md` (`## 1.2.3`), which becomes the release's notes.
+3. Merge to `main`.
+4. Run the **SDK release** workflow in the Nohead API repository. It runs this commit's smoke test against the API and pushes the tag `v1.2.3`.
+5. The tag starts `.github/workflows/release.yml`. It checks the version and its notes, tests, and stages the package on npm with provenance through trusted publishing (no token). Then it creates a draft GitHub release.
+6. Approve the staged version with 2FA, on npmjs.com, or with `npm stage list @nohead/sdk` and `npm stage approve <stage-id>`. Only then is it installable. Publish the draft GitHub release.
+
+## License
+
+MIT

package/dist/api-promise.d.ts

@@ -0,0 +1,50 @@
+import type { ListMeta } from "./generated/types.gen.ts";
+/** A response's data with the raw `Response`, from `withResponse()`. */
+export interface APIResponse<T> {
+    data: T;
+    response: Response;
+    /** The `X-Request-Id` header (`req_…`). */
+    requestId: string | undefined;
+}
+/**
+ * What every method returns: a promise of the resource, which also offers
+ * `withResponse()` for the raw response (headers, status) alongside it.
+ *
+ *   const record = await nohead.records.get(id)
+ *   const { data, response } = await nohead.records.get(id).withResponse()
+ */
+export declare class APIPromise<T> implements PromiseLike<T> {
+    #private;
+    constructor(raw: Promise<APIResponse<T>>);
+    /** The data together with the `Response` it came from. */
+    withResponse(): Promise<APIResponse<T>>;
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    finally(onfinally?: (() => void) | null): Promise<T>;
+    get [Symbol.toStringTag](): string;
+}
+/** One page of a list, iterable across the pages that follow it. */
+export declare class Page<T, Meta extends ListMeta = ListMeta> implements AsyncIterable<T> {
+    #private;
+    /** The items on this page. */
+    readonly data: T[];
+    /** `next_cursor` and `has_more` (and `total_estimate` for search). */
+    readonly meta: Meta;
+    constructor(data: T[], meta: Meta, fetch: (cursor: string) => Promise<Page<T, Meta>>);
+    hasNextPage(): boolean;
+    /** The next page; throws when there is none (check `hasNextPage()`). */
+    getNextPage(): Promise<Page<T, Meta>>;
+    /** Every item from this page on, fetching later pages as needed. */
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}
+/**
+ * What list methods return. Awaiting it gives the first page; iterating it
+ * walks every item across pages.
+ *
+ *   const page = await nohead.records.list("posts")
+ *   for await (const record of nohead.records.list("posts")) { … }
+ */
+export declare class PagePromise<T, Meta extends ListMeta = ListMeta> extends APIPromise<Page<T, Meta>> implements AsyncIterable<T> {
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+    get [Symbol.toStringTag](): string;
+}

package/dist/api-promise.js

@@ -0,0 +1,77 @@
+import { NoheadError } from "./errors.js";
+/**
+ * What every method returns: a promise of the resource, which also offers
+ * `withResponse()` for the raw response (headers, status) alongside it.
+ *
+ *   const record = await nohead.records.get(id)
+ *   const { data, response } = await nohead.records.get(id).withResponse()
+ */
+export class APIPromise {
+    #raw;
+    constructor(raw) {
+        this.#raw = raw;
+    }
+    /** The data together with the `Response` it came from. */
+    withResponse() {
+        return this.#raw;
+    }
+    then(onfulfilled, onrejected) {
+        return this.#raw.then((r) => r.data).then(onfulfilled, onrejected);
+    }
+    catch(onrejected) {
+        return this.then(undefined, onrejected);
+    }
+    finally(onfinally) {
+        return this.then().finally(onfinally);
+    }
+    get [Symbol.toStringTag]() {
+        return "APIPromise";
+    }
+}
+/** One page of a list, iterable across the pages that follow it. */
+export class Page {
+    /** The items on this page. */
+    data;
+    /** `next_cursor` and `has_more` (and `total_estimate` for search). */
+    meta;
+    #fetch;
+    constructor(data, meta, fetch) {
+        this.data = data;
+        this.meta = meta;
+        this.#fetch = fetch;
+    }
+    hasNextPage() {
+        return this.meta.has_more && this.meta.next_cursor !== null;
+    }
+    /** The next page; throws when there is none (check `hasNextPage()`). */
+    getNextPage() {
+        if (!this.hasNextPage()) {
+            return Promise.reject(new NoheadError("There is no next page"));
+        }
+        return this.#fetch(this.meta.next_cursor);
+    }
+    /** Every item from this page on, fetching later pages as needed. */
+    async *[Symbol.asyncIterator]() {
+        yield* this.data;
+        let next = this.hasNextPage() ? await this.getNextPage() : undefined;
+        while (next) {
+            yield* next.data;
+            next = next.hasNextPage() ? await next.getNextPage() : undefined;
+        }
+    }
+}
+/**
+ * What list methods return. Awaiting it gives the first page; iterating it
+ * walks every item across pages.
+ *
+ *   const page = await nohead.records.list("posts")
+ *   for await (const record of nohead.records.list("posts")) { … }
+ */
+export class PagePromise extends APIPromise {
+    async *[Symbol.asyncIterator]() {
+        yield* await this;
+    }
+    get [Symbol.toStringTag]() {
+        return "PagePromise";
+    }
+}

package/dist/client.d.ts

@@ -0,0 +1,47 @@
+import type { PagePromise } from "./api-promise.ts";
+import { type ClientOptions, type RequestOptions } from "./core.ts";
+import type * as G from "./generated/types.gen.ts";
+import { Assets } from "./resources/assets.ts";
+import { AuditEvents, FeatureFlags, Health, Me } from "./resources/other.ts";
+import { Records } from "./resources/records.ts";
+import { Collections, Fields, Migrations } from "./resources/schema.ts";
+import { Webhooks } from "./resources/webhooks.ts";
+import type { NoheadRecord, ProjectSearchParams, RecordData, SearchMeta } from "./types.ts";
+/**
+ * A client for the Nohead API, authenticated with a project API key.
+ *
+ *   import { Nohead } from "@nohead/sdk"
+ *
+ *   const nohead = new Nohead()   // NOHEAD_API_KEY
+ *   for await (const post of nohead.records.list("posts")) console.log(post.data.title)
+ */
+export declare class Nohead {
+    #private;
+    readonly records: Records;
+    readonly collections: Collections;
+    readonly fields: Fields;
+    readonly migrations: Migrations;
+    readonly assets: Assets;
+    readonly webhooks: Webhooks;
+    readonly auditEvents: AuditEvents;
+    readonly featureFlags: FeatureFlags;
+    readonly me: Me;
+    readonly health: Health;
+    constructor(options?: ClientOptions);
+    /**
+     * Full-text search across the key's project (or some of its
+     * collections), most relevant first, through the first 1,000 hits.
+     */
+    search<D = RecordData>(query: string, params?: ProjectSearchParams, options?: RequestOptions): PagePromise<NoheadRecord<D>, SearchMeta>;
+}
+/** The main types, also reachable as `Nohead.Record`, `Nohead.Collection`… */
+export declare namespace Nohead {
+    type Record<D = RecordData> = NoheadRecord<D>;
+    type Collection = G.Collection;
+    type Field = G.Field;
+    type Asset = G.Asset;
+    type Webhook = G.Webhook;
+    type Schema = G.Schema;
+    type FieldMigration = G.FieldMigration;
+    type RecordRevision = G.RecordRevision;
+}

package/dist/client.js

@@ -0,0 +1,48 @@
+import { Core } from "./core.js";
+import { Assets } from "./resources/assets.js";
+import { AuditEvents, FeatureFlags, Health, Me } from "./resources/other.js";
+import { Records } from "./resources/records.js";
+import { Collections, Fields, Migrations } from "./resources/schema.js";
+import { Webhooks } from "./resources/webhooks.js";
+/**
+ * A client for the Nohead API, authenticated with a project API key.
+ *
+ *   import { Nohead } from "@nohead/sdk"
+ *
+ *   const nohead = new Nohead()   // NOHEAD_API_KEY
+ *   for await (const post of nohead.records.list("posts")) console.log(post.data.title)
+ */
+export class Nohead {
+    records;
+    collections;
+    fields;
+    migrations;
+    assets;
+    webhooks;
+    auditEvents;
+    featureFlags;
+    me;
+    health;
+    #core;
+    constructor(options = {}) {
+        const core = new Core(options);
+        this.#core = core;
+        this.records = new Records(core);
+        this.collections = new Collections(core);
+        this.fields = new Fields(core);
+        this.migrations = new Migrations(core);
+        this.assets = new Assets(core);
+        this.webhooks = new Webhooks(core);
+        this.auditEvents = new AuditEvents(core);
+        this.featureFlags = new FeatureFlags(core);
+        this.me = new Me(core);
+        this.health = new Health(core);
+    }
+    /**
+     * Full-text search across the key's project (or some of its
+     * collections), most relevant first, through the first 1,000 hits.
+     */
+    search(query, params = {}, options) {
+        return this.#core.paginate("projects_search", { query: { q: query, ...params } }, options);
+    }
+}