@nohead/sdk 0.0.0 → 0.1.0

package/dist/generated/types.gen.js

@@ -0,0 +1,2 @@
+// This file is auto-generated by @hey-api/openapi-ts
+export {};

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { Nohead } from "./client.ts";
+export { APIPromise, Page, PagePromise, type APIResponse, } from "./api-promise.ts";
+export type { ClientOptions, ConditionalRequestOptions, RequestOptions, } from "./core.ts";
+export { APIError, AbortError, AuthenticationError, AuthorizationError, ConflictError, ConnectionError, InternalServerError, InvalidRequestError, NoheadError, NotFoundError, PlanLimitExceededError, PreconditionFailedError, RateLimitError, ServiceUnavailableError, TimeoutError, UploadError, ValidationError, WebhookVerificationError, } from "./errors.ts";
+export type { Uploadable, UploadParams } from "./resources/assets.ts";
+export type * from "./types.ts";
+export { unwrapWebhook, type AssetEvent, type RecordEvent, type SchemaChangedEvent, type UnwrapOptions, type WebhookEvent, type WebhookHeaders, type WebhookTestEvent, } from "./webhooks.ts";
+export { VERSION } from "./version.ts";

package/dist/index.js

@@ -0,0 +1,5 @@
+export { Nohead } from "./client.js";
+export { APIPromise, Page, PagePromise, } from "./api-promise.js";
+export { APIError, AbortError, AuthenticationError, AuthorizationError, ConflictError, ConnectionError, InternalServerError, InvalidRequestError, NoheadError, NotFoundError, PlanLimitExceededError, PreconditionFailedError, RateLimitError, ServiceUnavailableError, TimeoutError, UploadError, ValidationError, WebhookVerificationError, } from "./errors.js";
+export { unwrapWebhook, } from "./webhooks.js";
+export { VERSION } from "./version.js";

package/dist/resources/assets.d.ts

@@ -0,0 +1,44 @@
+import type { APIPromise, PagePromise } from "../api-promise.ts";
+import type { RequestOptions } from "../core.ts";
+import type { Asset, AssetUpload, AssetUploadCreate, DownloadUrl, ImageUrl } from "../generated/types.gen.ts";
+import type { DeletedListParams, ImageUrlParams } from "../types.ts";
+import { Resource } from "./resource.ts";
+/** What `assets.upload` accepts. A stream needs `byte_size`. */
+export type Uploadable = Blob | ArrayBuffer | Uint8Array | ReadableStream;
+export interface UploadParams {
+    /** Defaults to a `File`'s name, else `upload`. */
+    filename?: string;
+    /** Defaults to the `Blob`'s type, else `application/octet-stream`. */
+    content_type?: string;
+    /** Required for a `ReadableStream`; known for everything else. */
+    byte_size?: number;
+}
+/** Files of the key's project. `asset` is an asset ID (`ast_…`). */
+export declare class Assets extends Resource {
+    /**
+     * Uploads a file and returns the `ready` asset: creates the upload, sends
+     * the bytes straight to storage, then completes it (which checks the
+     * file). Throws `UploadError` if storage refuses the bytes, and
+     * `ValidationError` if the file fails the checks.
+     *
+     *   import { openAsBlob } from "node:fs"
+     *   const asset = await nohead.assets.upload(await openAsBlob("a.jpg"), { filename: "a.jpg" })
+     */
+    upload(file: Uploadable, params?: UploadParams, options?: RequestOptions): Promise<Asset>;
+    /**
+     * The first step of an upload: a `pending` asset and a presigned URL to
+     * `PUT` the bytes to (for example from a browser). Then `complete` it.
+     */
+    createUpload(params: AssetUploadCreate, options?: RequestOptions): APIPromise<AssetUpload>;
+    /** Checks an uploaded file and marks the asset `ready`. */
+    complete(asset: string, options?: RequestOptions): APIPromise<Asset>;
+    list(params?: DeletedListParams, options?: RequestOptions): PagePromise<Asset>;
+    get(asset: string, options?: RequestOptions): APIPromise<Asset>;
+    /** Soft-deletes the asset; the file is purged after 30 days. */
+    delete(asset: string, options?: RequestOptions): APIPromise<Asset>;
+    restore(asset: string, options?: RequestOptions): APIPromise<Asset>;
+    /** A signed, cacheable URL of an image rendition (`url`). */
+    imageUrl(asset: string, params?: ImageUrlParams, options?: RequestOptions): APIPromise<ImageUrl>;
+    /** A 15-minute link to download the original file (`url`). */
+    downloadUrl(asset: string, options?: RequestOptions): APIPromise<DownloadUrl>;
+}

package/dist/resources/assets.js

@@ -0,0 +1,86 @@
+import { AbortError, UploadError } from "../errors.js";
+import { Resource } from "./resource.js";
+/** Files of the key's project. `asset` is an asset ID (`ast_…`). */
+export class Assets extends Resource {
+    /**
+     * Uploads a file and returns the `ready` asset: creates the upload, sends
+     * the bytes straight to storage, then completes it (which checks the
+     * file). Throws `UploadError` if storage refuses the bytes, and
+     * `ValidationError` if the file fails the checks.
+     *
+     *   import { openAsBlob } from "node:fs"
+     *   const asset = await nohead.assets.upload(await openAsBlob("a.jpg"), { filename: "a.jpg" })
+     */
+    async upload(file, params = {}, options) {
+        const byteSize = params.byte_size ?? sizeOf(file);
+        if (byteSize === undefined) {
+            throw new UploadError("Uploading a stream needs `byte_size`");
+        }
+        const { asset, upload } = await this.createUpload({
+            filename: params.filename ??
+                (typeof File !== "undefined" && file instanceof File
+                    ? file.name
+                    : "upload"),
+            content_type: params.content_type ??
+                ((file instanceof Blob && file.type) || "application/octet-stream"),
+            byte_size: byteSize,
+        }, options);
+        const stream = file instanceof ReadableStream;
+        const response = await this.core
+            .fetchWithRetries(upload.url, {
+            method: upload.method,
+            headers: upload.headers,
+            body: file,
+            ...(stream ? { duplex: "half" } : {}),
+        }, { ...options, retry: !stream })
+            .catch((error) => {
+            if (error instanceof AbortError)
+                throw error;
+            throw new UploadError(`Could not upload ${asset.filename}: ${error.message}`, undefined, { cause: error });
+        });
+        if (!response.ok) {
+            throw new UploadError(`Storage refused the upload of ${asset.filename} (${response.status})`, response.status);
+        }
+        return this.complete(asset.id, options);
+    }
+    /**
+     * The first step of an upload: a `pending` asset and a presigned URL to
+     * `PUT` the bytes to (for example from a browser). Then `complete` it.
+     */
+    createUpload(params, options) {
+        return this.core.request("assets_upload", { body: params }, options);
+    }
+    /** Checks an uploaded file and marks the asset `ready`. */
+    complete(asset, options) {
+        return this.core.request("assets_complete", { path: { asset_id: asset } }, options);
+    }
+    list(params = {}, options) {
+        return this.core.paginate("assets_list", { query: params }, options);
+    }
+    get(asset, options) {
+        return this.core.request("assets_get", { path: { asset_id: asset } }, options);
+    }
+    /** Soft-deletes the asset; the file is purged after 30 days. */
+    delete(asset, options) {
+        return this.core.request("assets_delete", { path: { asset_id: asset } }, options);
+    }
+    restore(asset, options) {
+        return this.core.request("assets_restore", { path: { asset_id: asset } }, options);
+    }
+    /** A signed, cacheable URL of an image rendition (`url`). */
+    imageUrl(asset, params = {}, options) {
+        return this.core.request("assets_image_url", { path: { asset_id: asset }, query: params }, options);
+    }
+    /** A 15-minute link to download the original file (`url`). */
+    downloadUrl(asset, options) {
+        return this.core.request("assets_download_url", { path: { asset_id: asset } }, options);
+    }
+}
+function sizeOf(file) {
+    if (file instanceof Blob)
+        return file.size;
+    if (file instanceof ArrayBuffer || ArrayBuffer.isView(file)) {
+        return file.byteLength;
+    }
+    return undefined;
+}

package/dist/resources/other.d.ts

@@ -0,0 +1,20 @@
+import type { APIPromise, PagePromise } from "../api-promise.ts";
+import type { RequestOptions } from "../core.ts";
+import type { AuditEvent, FeatureFlags as FeatureFlagList, Health as HealthStatus, Principal } from "../generated/types.gen.ts";
+import type { AuditEventListParams } from "../types.ts";
+import { Resource } from "./resource.ts";
+/** The project's activity log, newest first. Needs the `audit:read` scope. */
+export declare class AuditEvents extends Resource {
+    list(params?: AuditEventListParams, options?: RequestOptions): PagePromise<AuditEvent>;
+}
+export declare class FeatureFlags extends Resource {
+    /** Flags evaluated for the key's project. */
+    list(options?: RequestOptions): APIPromise<FeatureFlagList>;
+}
+export declare class Me extends Resource {
+    /** The API key: its project, scopes, `published_only` and expiry. */
+    get(options?: RequestOptions): APIPromise<Principal>;
+}
+export declare class Health extends Resource {
+    check(options?: RequestOptions): APIPromise<HealthStatus>;
+}

package/dist/resources/other.js

@@ -0,0 +1,24 @@
+import { Resource } from "./resource.js";
+/** The project's activity log, newest first. Needs the `audit:read` scope. */
+export class AuditEvents extends Resource {
+    list(params = {}, options) {
+        return this.core.paginate("audit_events_list_for_project", { query: params }, options);
+    }
+}
+export class FeatureFlags extends Resource {
+    /** Flags evaluated for the key's project. */
+    list(options) {
+        return this.core.request("feature_flags_list", {}, options);
+    }
+}
+export class Me extends Resource {
+    /** The API key: its project, scopes, `published_only` and expiry. */
+    get(options) {
+        return this.core.request("me_get", {}, options);
+    }
+}
+export class Health extends Resource {
+    check(options) {
+        return this.core.request("health_check", {}, options);
+    }
+}

package/dist/resources/records.d.ts

@@ -0,0 +1,52 @@
+import type { APIPromise, PagePromise } from "../api-promise.ts";
+import type { ConditionalRequestOptions, RequestOptions } from "../core.ts";
+import type { RecordData, RecordDiff, RecordRevision, RecordRevisionDetail, RevertPreview, BulkRecordsResult, RecordCount } from "../generated/types.gen.ts";
+import type { DryRunParams, NoheadRecord, RecordBulkParams, RecordCountParams, RecordCreateParams, RecordDiffParams, RecordGetParams, RecordListParams, RecordScheduleParams, RecordSearchParams, RecordUpdateParams, RevisionListParams, SearchMeta } from "../types.ts";
+import { Resource } from "./resource.ts";
+/**
+ * Records: the content of a collection. `collection` is a collection ID or
+ * slug; `record` a record ID (`rec_…`).
+ */
+export declare class Records extends Resource {
+    readonly revisions: Revisions;
+    /** A collection's records, newest first by default. */
+    list<D = RecordData>(collection: string, params?: RecordListParams, options?: RequestOptions): PagePromise<NoheadRecord<D>>;
+    get<D = RecordData>(record: string, params?: RecordGetParams, options?: RequestOptions): APIPromise<NoheadRecord<D>>;
+    /** Creates a draft. */
+    create<D = RecordData>(collection: string, params: RecordCreateParams<D>, options?: RequestOptions): APIPromise<NoheadRecord<D>>;
+    /** Sets the given fields (`null` clears one); others keep their values. */
+    update<D = RecordData>(record: string, params: RecordUpdateParams<D>, options?: ConditionalRequestOptions): APIPromise<NoheadRecord<D>>;
+    /** Soft-deletes the record: `restore` brings it back within 30 days. */
+    delete<D = RecordData>(record: string, options?: ConditionalRequestOptions): APIPromise<NoheadRecord<D>>;
+    restore<D = RecordData>(record: string, options?: RequestOptions): APIPromise<NoheadRecord<D>>;
+    publish<D = RecordData>(record: string, options?: ConditionalRequestOptions): APIPromise<NoheadRecord<D>>;
+    unpublish<D = RecordData>(record: string, options?: ConditionalRequestOptions): APIPromise<NoheadRecord<D>>;
+    /** Publishes and/or unpublishes the record later. */
+    schedule<D = RecordData>(record: string, params: RecordScheduleParams, options?: RequestOptions): APIPromise<NoheadRecord<D>>;
+    /** Clears both scheduled times. */
+    unschedule<D = RecordData>(record: string, options?: RequestOptions): APIPromise<NoheadRecord<D>>;
+    count(collection: string, params?: RecordCountParams, options?: RequestOptions): APIPromise<RecordCount>;
+    /**
+     * Publishes, unpublishes, deletes, restores or updates up to 100 records.
+     * Each record succeeds or fails on its own; see `results`.
+     */
+    bulk(collection: string, params: RecordBulkParams, options?: RequestOptions): APIPromise<BulkRecordsResult>;
+    /** The changes between two revisions. */
+    diff(record: string, params: RecordDiffParams, options?: RequestOptions): APIPromise<RecordDiff>;
+    /**
+     * Full-text search in one collection (`search_enabled` collections).
+     * Pages through the first 1,000 hits, most relevant first.
+     */
+    search<D = RecordData>(collection: string, query: string, params?: RecordSearchParams, options?: RequestOptions): PagePromise<NoheadRecord<D>, SearchMeta>;
+}
+/** A record's version history. `revision` is a revision number. */
+export declare class Revisions extends Resource {
+    /** Newest first. */
+    list(record: string, params?: RevisionListParams, options?: RequestOptions): PagePromise<RecordRevision>;
+    get(record: string, revision: number, options?: RequestOptions): APIPromise<RecordRevisionDetail>;
+    /** Restores the record's data as of `revision`, as a new revision. */
+    revert(record: string, revision: number, params: {
+        dry_run: true;
+    }, options?: ConditionalRequestOptions): APIPromise<RevertPreview>;
+    revert<D = RecordData>(record: string, revision: number, params?: DryRunParams, options?: ConditionalRequestOptions): APIPromise<NoheadRecord<D>>;
+}

package/dist/resources/records.js

@@ -0,0 +1,78 @@
+import { Resource } from "./resource.js";
+/**
+ * Records: the content of a collection. `collection` is a collection ID or
+ * slug; `record` a record ID (`rec_…`).
+ */
+export class Records extends Resource {
+    revisions = new Revisions(this.core);
+    /** A collection's records, newest first by default. */
+    list(collection, params = {}, options) {
+        return this.core.paginate("records_list", { path: { collection_id: collection }, query: params }, options);
+    }
+    get(record, params = {}, options) {
+        return this.core.request("records_get", { path: { record_id: record }, query: params }, options);
+    }
+    /** Creates a draft. */
+    create(collection, params, options) {
+        return this.core.request("records_create", { path: { collection_id: collection }, body: params }, options);
+    }
+    /** Sets the given fields (`null` clears one); others keep their values. */
+    update(record, params, options) {
+        return this.core.request("records_update", { path: { record_id: record }, body: params }, options);
+    }
+    /** Soft-deletes the record: `restore` brings it back within 30 days. */
+    delete(record, options) {
+        return this.core.request("records_delete", { path: { record_id: record } }, options);
+    }
+    restore(record, options) {
+        return this.core.request("records_restore", { path: { record_id: record } }, options);
+    }
+    publish(record, options) {
+        return this.core.request("records_publish", { path: { record_id: record } }, options);
+    }
+    unpublish(record, options) {
+        return this.core.request("records_unpublish", { path: { record_id: record } }, options);
+    }
+    /** Publishes and/or unpublishes the record later. */
+    schedule(record, params, options) {
+        return this.core.request("records_schedule", { path: { record_id: record }, body: params }, options);
+    }
+    /** Clears both scheduled times. */
+    unschedule(record, options) {
+        return this.core.request("records_unschedule", { path: { record_id: record } }, options);
+    }
+    count(collection, params = {}, options) {
+        return this.core.request("records_count", { path: { collection_id: collection }, query: params }, options);
+    }
+    /**
+     * Publishes, unpublishes, deletes, restores or updates up to 100 records.
+     * Each record succeeds or fails on its own; see `results`.
+     */
+    bulk(collection, params, options) {
+        return this.core.request("records_bulk", { path: { collection_id: collection }, body: params }, options);
+    }
+    /** The changes between two revisions. */
+    diff(record, params, options) {
+        return this.core.request("records_diff", { path: { record_id: record }, query: params }, options);
+    }
+    /**
+     * Full-text search in one collection (`search_enabled` collections).
+     * Pages through the first 1,000 hits, most relevant first.
+     */
+    search(collection, query, params = {}, options) {
+        return this.core.paginate("collections_search", { path: { collection_id: collection }, query: { q: query, ...params } }, options);
+    }
+}
+/** A record's version history. `revision` is a revision number. */
+export class Revisions extends Resource {
+    /** Newest first. */
+    list(record, params = {}, options) {
+        return this.core.paginate("record_revisions_list", { path: { record_id: record }, query: params }, options);
+    }
+    get(record, revision, options) {
+        return this.core.request("record_revisions_get", { path: { record_id: record, revision } }, options);
+    }
+    revert(record, revision, params = {}, options) {
+        return this.core.request("record_revisions_revert", { path: { record_id: record, revision }, query: params }, options);
+    }
+}

package/dist/resources/resource.d.ts

@@ -0,0 +1,5 @@
+import type { Core } from "../core.ts";
+export declare abstract class Resource {
+    protected readonly core: Core;
+    constructor(core: Core);
+}

package/dist/resources/resource.js

@@ -0,0 +1,6 @@
+export class Resource {
+    core;
+    constructor(core) {
+        this.core = core;
+    }
+}

package/dist/resources/schema.d.ts

@@ -0,0 +1,64 @@
+import type { APIPromise, PagePromise } from "../api-promise.ts";
+import type { RequestOptions } from "../core.ts";
+import type { Collection, CollectionCreate, CollectionUpdate, Field, FieldCreate, FieldMigration, FieldMigrationPreview, FieldUpdate, Schema, SchemaChange, SchemaChangeDetail, SearchIndex } from "../generated/types.gen.ts";
+import type { DeletedListParams, DryRunParams, FieldMigrateParams, ListParams, SchemaParams } from "../types.ts";
+import { Resource } from "./resource.ts";
+/** Collections of the key's project. `collection` is an ID or slug. */
+export declare class Collections extends Resource {
+    readonly schemaChanges: SchemaChanges;
+    readonly searchIndex: SearchIndexes;
+    list(params?: DeletedListParams, options?: RequestOptions): PagePromise<Collection>;
+    get(collection: string, options?: RequestOptions): APIPromise<Collection>;
+    /** Creates a collection, optionally with its fields. */
+    create(params: CollectionCreate, options?: RequestOptions): APIPromise<Collection>;
+    update(collection: string, params: CollectionUpdate, options?: RequestOptions): APIPromise<Collection>;
+    /** Soft-deletes the collection and its records for 30 days. */
+    delete(collection: string, options?: RequestOptions): APIPromise<Collection>;
+    restore(collection: string, options?: RequestOptions): APIPromise<Collection>;
+    /** The collection's schema, now or at a past `version`. */
+    schema(collection: string, params?: SchemaParams, options?: RequestOptions): APIPromise<Schema>;
+}
+/** A collection's schema history, newest first. */
+export declare class SchemaChanges extends Resource {
+    list(collection: string, params?: ListParams, options?: RequestOptions): PagePromise<SchemaChange>;
+    get(collection: string, schemaChange: string, options?: RequestOptions): APIPromise<SchemaChangeDetail>;
+}
+/** A collection's search index. */
+export declare class SearchIndexes extends Resource {
+    get(collection: string, options?: RequestOptions): APIPromise<SearchIndex>;
+    /** Rebuilds the index from the records; searches keep working meanwhile. */
+    rebuild(collection: string, options?: RequestOptions): APIPromise<SearchIndex>;
+}
+/** Fields of a collection. `field` is a field ID (`fld_…`). */
+export declare class Fields extends Resource {
+    list(collection: string, params?: DeletedListParams, options?: RequestOptions): PagePromise<Field>;
+    create(collection: string, params: FieldCreate, options?: RequestOptions): APIPromise<Field>;
+    /**
+     * Renames, describes or loosens a field. Changes that rewrite record
+     * values (type, `multiple`, tighter rules) are `migrate`.
+     */
+    update(field: string, params: FieldUpdate, options?: RequestOptions): APIPromise<Field>;
+    /** Soft-deletes the field: its values return with `restore` for 30 days. */
+    delete(field: string, options?: RequestOptions): APIPromise<Field>;
+    restore(field: string, options?: RequestOptions): APIPromise<Field>;
+    /** Puts the collection's fields in this order. */
+    reorder(collection: string, params: {
+        field_ids: string[];
+    }, options?: RequestOptions): APIPromise<Collection>;
+    /** Stops accepting a renamed field's old API key before its 6 months end. */
+    removeAlias(field: string, alias: string, options?: RequestOptions): APIPromise<Field>;
+    /**
+     * Starts a field migration (type, `multiple`, tighter configuration or a
+     * backfill) that rewrites every record. With `dry_run`, previews it.
+     */
+    migrate(field: string, params: FieldMigrateParams & {
+        dry_run: true;
+    }, options?: RequestOptions): APIPromise<FieldMigrationPreview>;
+    migrate(field: string, params: FieldMigrateParams & DryRunParams, options?: RequestOptions): APIPromise<FieldMigration>;
+}
+/** Field migrations. While one runs, its collection is read-only. */
+export declare class Migrations extends Resource {
+    list(collection: string, params?: ListParams, options?: RequestOptions): PagePromise<FieldMigration>;
+    get(migration: string, options?: RequestOptions): APIPromise<FieldMigration>;
+    cancel(migration: string, options?: RequestOptions): APIPromise<FieldMigration>;
+}

package/dist/resources/schema.js

@@ -0,0 +1,97 @@
+import { Resource } from "./resource.js";
+/** Collections of the key's project. `collection` is an ID or slug. */
+export class Collections extends Resource {
+    schemaChanges = new SchemaChanges(this.core);
+    searchIndex = new SearchIndexes(this.core);
+    list(params = {}, options) {
+        return this.core.paginate("collections_list", { query: params }, options);
+    }
+    get(collection, options) {
+        return this.core.request("collections_get", { path: { collection_id: collection } }, options);
+    }
+    /** Creates a collection, optionally with its fields. */
+    create(params, options) {
+        return this.core.request("collections_create", { body: params }, options);
+    }
+    update(collection, params, options) {
+        return this.core.request("collections_update", { path: { collection_id: collection }, body: params }, options);
+    }
+    /** Soft-deletes the collection and its records for 30 days. */
+    delete(collection, options) {
+        return this.core.request("collections_delete", { path: { collection_id: collection } }, options);
+    }
+    restore(collection, options) {
+        return this.core.request("collections_restore", { path: { collection_id: collection } }, options);
+    }
+    /** The collection's schema, now or at a past `version`. */
+    schema(collection, params = {}, options) {
+        return this.core.request("collections_get_schema", { path: { collection_id: collection }, query: params }, options);
+    }
+}
+/** A collection's schema history, newest first. */
+export class SchemaChanges extends Resource {
+    list(collection, params = {}, options) {
+        return this.core.paginate("schema_changes_list", { path: { collection_id: collection }, query: params }, options);
+    }
+    get(collection, schemaChange, options) {
+        return this.core.request("schema_changes_get", {
+            path: { collection_id: collection, schema_change_id: schemaChange },
+        }, options);
+    }
+}
+/** A collection's search index. */
+export class SearchIndexes extends Resource {
+    get(collection, options) {
+        return this.core.request("search_index_get", { path: { collection_id: collection } }, options);
+    }
+    /** Rebuilds the index from the records; searches keep working meanwhile. */
+    rebuild(collection, options) {
+        return this.core.request("search_index_rebuild", { path: { collection_id: collection } }, options);
+    }
+}
+/** Fields of a collection. `field` is a field ID (`fld_…`). */
+export class Fields extends Resource {
+    list(collection, params = {}, options) {
+        return this.core.paginate("fields_list", { path: { collection_id: collection }, query: params }, options);
+    }
+    create(collection, params, options) {
+        return this.core.request("fields_create", { path: { collection_id: collection }, body: params }, options);
+    }
+    /**
+     * Renames, describes or loosens a field. Changes that rewrite record
+     * values (type, `multiple`, tighter rules) are `migrate`.
+     */
+    update(field, params, options) {
+        return this.core.request("fields_update", { path: { field_id: field }, body: params }, options);
+    }
+    /** Soft-deletes the field: its values return with `restore` for 30 days. */
+    delete(field, options) {
+        return this.core.request("fields_delete", { path: { field_id: field } }, options);
+    }
+    restore(field, options) {
+        return this.core.request("fields_restore", { path: { field_id: field } }, options);
+    }
+    /** Puts the collection's fields in this order. */
+    reorder(collection, params, options) {
+        return this.core.request("fields_reorder", { path: { collection_id: collection }, body: params }, options);
+    }
+    /** Stops accepting a renamed field's old API key before its 6 months end. */
+    removeAlias(field, alias, options) {
+        return this.core.request("fields_remove_alias", { path: { field_id: field, alias } }, options);
+    }
+    migrate(field, { dry_run, ...body }, options) {
+        return this.core.request("fields_migrate", { path: { field_id: field }, query: { dry_run }, body }, options);
+    }
+}
+/** Field migrations. While one runs, its collection is read-only. */
+export class Migrations extends Resource {
+    list(collection, params = {}, options) {
+        return this.core.paginate("migrations_list", { path: { collection_id: collection }, query: params }, options);
+    }
+    get(migration, options) {
+        return this.core.request("migrations_get", { path: { migration_id: migration } }, options);
+    }
+    cancel(migration, options) {
+        return this.core.request("migrations_cancel", { path: { migration_id: migration } }, options);
+    }
+}

package/dist/resources/webhooks.d.ts

@@ -0,0 +1,32 @@
+import type { APIPromise, PagePromise } from "../api-promise.ts";
+import type { RequestOptions } from "../core.ts";
+import type { Webhook, WebhookCreate, WebhookDelivery, WebhookDeliveryDetail, WebhookUpdate, WebhookWithSecret } from "../generated/types.gen.ts";
+import type { DeliveryListParams, ListParams, RecordData } from "../types.ts";
+import { type UnwrapOptions, type WebhookEvent, type WebhookHeaders } from "../webhooks.ts";
+import { Resource } from "./resource.ts";
+/** Webhooks of the key's project. `webhook` is a webhook ID (`wh_…`). */
+export declare class Webhooks extends Resource {
+    readonly deliveries: Deliveries;
+    list(params?: ListParams, options?: RequestOptions): PagePromise<Webhook>;
+    get(webhook: string, options?: RequestOptions): APIPromise<Webhook>;
+    /** Subscribes a URL. The response is the only time `secret` is shown. */
+    create(params: WebhookCreate, options?: RequestOptions): APIPromise<WebhookWithSecret>;
+    update(webhook: string, params: WebhookUpdate, options?: RequestOptions): APIPromise<Webhook>;
+    delete(webhook: string, options?: RequestOptions): APIPromise<Webhook>;
+    /** A new signing secret; the old one stops working at once. */
+    rotateSecret(webhook: string, options?: RequestOptions): APIPromise<WebhookWithSecret>;
+    /** Sends a `webhook.test` event to the URL. */
+    test(webhook: string, options?: RequestOptions): APIPromise<WebhookDelivery>;
+    /**
+     * Checks a webhook request's signature and returns its event (see
+     * `unwrapWebhook` in `@nohead/sdk/webhooks`, which needs no client).
+     */
+    unwrap<D = RecordData>(body: string | ArrayBuffer | Uint8Array, headers: WebhookHeaders, options: UnwrapOptions): Promise<WebhookEvent<D>>;
+}
+/** Delivery attempts of a webhook's events. */
+export declare class Deliveries extends Resource {
+    list(webhook: string, params?: DeliveryListParams, options?: RequestOptions): PagePromise<WebhookDelivery>;
+    get(delivery: string, options?: RequestOptions): APIPromise<WebhookDeliveryDetail>;
+    /** Sends the event again. */
+    retry(delivery: string, options?: RequestOptions): APIPromise<WebhookDelivery>;
+}

package/dist/resources/webhooks.js

@@ -0,0 +1,50 @@
+import { unwrapWebhook, } from "../webhooks.js";
+import { Resource } from "./resource.js";
+/** Webhooks of the key's project. `webhook` is a webhook ID (`wh_…`). */
+export class Webhooks extends Resource {
+    deliveries = new Deliveries(this.core);
+    list(params = {}, options) {
+        return this.core.paginate("webhooks_list", { query: params }, options);
+    }
+    get(webhook, options) {
+        return this.core.request("webhooks_get", { path: { webhook_id: webhook } }, options);
+    }
+    /** Subscribes a URL. The response is the only time `secret` is shown. */
+    create(params, options) {
+        return this.core.request("webhooks_create", { body: params }, options);
+    }
+    update(webhook, params, options) {
+        return this.core.request("webhooks_update", { path: { webhook_id: webhook }, body: params }, options);
+    }
+    delete(webhook, options) {
+        return this.core.request("webhooks_delete", { path: { webhook_id: webhook } }, options);
+    }
+    /** A new signing secret; the old one stops working at once. */
+    rotateSecret(webhook, options) {
+        return this.core.request("webhooks_rotate_secret", { path: { webhook_id: webhook } }, options);
+    }
+    /** Sends a `webhook.test` event to the URL. */
+    test(webhook, options) {
+        return this.core.request("webhooks_test", { path: { webhook_id: webhook } }, options);
+    }
+    /**
+     * Checks a webhook request's signature and returns its event (see
+     * `unwrapWebhook` in `@nohead/sdk/webhooks`, which needs no client).
+     */
+    unwrap(body, headers, options) {
+        return unwrapWebhook(body, headers, options);
+    }
+}
+/** Delivery attempts of a webhook's events. */
+export class Deliveries extends Resource {
+    list(webhook, params = {}, options) {
+        return this.core.paginate("webhook_deliveries_list", { path: { webhook_id: webhook }, query: params }, options);
+    }
+    get(delivery, options) {
+        return this.core.request("webhook_deliveries_get", { path: { delivery_id: delivery } }, options);
+    }
+    /** Sends the event again. */
+    retry(delivery, options) {
+        return this.core.request("webhook_deliveries_retry", { path: { delivery_id: delivery } }, options);
+    }
+}