json-rest-api 2.4.0 → 3.0.0

package/types/errors.d.ts

@@ -116,3 +116,48 @@ export class RestApiTemporalDataError extends RestApiError {
   details: { field?: string; resourceType?: string; fieldType?: string; source: string }
   toJSON(): SerializedError & Pick<RestApiTemporalDataError, 'code' | 'type' | 'statusCode' | 'details'>
 }
+
+export class RestApiBulkWriteUnsupportedError extends RestApiError {
+  constructor(options?: { resourceType?: string; operation?: string; reason?: string; hooks?: string[] })
+  code: 'REST_API_BULK_WRITE_UNSUPPORTED'
+  type: 'rest_api_bulk_write_unsupported'
+  statusCode: 422
+  /** `hooks` names the per-record hooks that caused the refusal; HTTP responses leave details out. */
+  details: { resourceType?: string; operation?: string; reason?: string; hooks?: string[] }
+  toJSON(): SerializedError & Pick<RestApiBulkWriteUnsupportedError, 'code' | 'type' | 'statusCode' | 'details'>
+}
+
+// Reports only how many requested records are missing or outside the caller's scope.
+export class RestApiRecordsNotFoundError extends RestApiResourceError {
+  constructor(options?: { resourceType?: string; missing?: number })
+  subtype: 'not_found'
+  details: { resourceType?: string; missing?: number }
+}
+
+export class RestApiBulkInsertIdsError extends RestApiError {
+  constructor(options?: { resourceType?: string; expected?: number; verified?: number })
+  code: 'REST_API_BULK_INSERT_IDS'
+  type: 'rest_api_bulk_insert_ids'
+  details: { resourceType?: string; expected?: number; verified?: number }
+  toJSON(): SerializedError & Pick<RestApiBulkInsertIdsError, 'code' | 'type' | 'details'>
+}
+
+export class RestApiLockOutsideTransactionError extends RestApiValidationError {
+  constructor(options?: { resourceType?: string; operation?: string })
+}
+
+export class RestApiScopedQueryReadOnlyError extends RestApiError {
+  constructor(options?: { resourceType?: string; method?: string })
+  code: 'REST_API_SCOPED_QUERY_READ_ONLY'
+  type: 'rest_api_scoped_query_read_only'
+  details: { resourceType?: string; method?: string }
+  toJSON(): SerializedError & Pick<RestApiScopedQueryReadOnlyError, 'code' | 'type' | 'details'>
+}
+
+export class RestApiRowLimitError extends RestApiError {
+  constructor(options?: { resourceType?: string; rowLimit?: number; operation?: 'queryAll' | 'lockWhere' })
+  code: 'REST_API_ROW_LIMIT'
+  type: 'rest_api_row_limit'
+  details: { resourceType?: string; rowLimit?: number; operation: 'queryAll' | 'lockWhere' }
+  toJSON(): SerializedError & Pick<RestApiRowLimitError, 'code' | 'type' | 'details'>
+}

package/types/hook-context.d.ts

@@ -169,10 +169,31 @@ export interface HookContextMap<Context extends object = Record<string, unknown>
   finishPostRelationship: RelationshipHookContext<Context, 'postRelationship'>
   finishPatchRelationship: RelationshipHookContext<Context, 'patchRelationship'>
   finishDeleteRelationship: RelationshipHookContext<Context, 'deleteRelationship'>
+  // Many-row operations: once per call. ids are the affected records' ids as strings
+  // (for a create, set from afterDataCallPostMany; undefined for rows an ignore skipped).
+  beforeProcessingPostMany: ManyRowHookContext<Context, 'postMany'>
+  beforeDataCallPostMany: ManyRowHookContext<Context, 'postMany'>
+  afterDataCallPostMany: ManyRowHookContext<Context, 'postMany'>
+  beforeProcessingPatchMany: ManyRowHookContext<Context, 'patchMany' | 'patchWhereIds' | 'patchWhere'>
+  beforeDataCallPatchMany: ManyRowHookContext<Context, 'patchMany' | 'patchWhereIds' | 'patchWhere'>
+  afterDataCallPatchMany: ManyRowHookContext<Context, 'patchMany' | 'patchWhereIds' | 'patchWhere'>
+  beforeDataCallDeleteMany: ManyRowHookContext<Context, 'deleteMany' | 'deleteWhere'>
+  afterDataCallDeleteMany: ManyRowHookContext<Context, 'deleteMany' | 'deleteWhere'>
   afterCommit: HookContext<Context>
   afterRollback: HookContext<Context>
 }
 
+export type ManyRowHookContext<Context extends object = Record<string, unknown>, Method extends string = string> = HookContext<Context> & {
+  readonly method: Method
+  readonly scopeName: string
+  readonly transaction: ManagedTransaction
+  // JSON:API documents of the rows, in input order (creates and patches).
+  readonly inputRecords?: Array<{ data: { id?: InputResourceId; attributes?: Record<string, unknown>; relationships?: Record<string, unknown> } }>
+  // Patches: fields some row sets with a knex.raw value (those values are not in inputRecords).
+  readonly rawFields?: string[]
+  readonly ids?: Array<string | undefined>
+}
+
 export type KnownHookName = keyof HookContextMap
 export type HookArguments<Event extends KnownHookName, Context extends object = Record<string, unknown>> =
   Omit<RuntimeArguments, 'context'> & { context: HookContextMap<Context>[Event] }

package/types/plugin-options.d.ts

@@ -25,6 +25,8 @@ export interface HttpConnectorOptions {
 export interface ResourceVersionOptions {
   // Compilation validates that this names a stored, untransformed string attribute.
   versionField?: string
+  // A stored, non-nullable integer advanced by one on every update.
+  lockVersionField?: string
 }
 
 export type CorsOrigin = string | RegExp | ((origin: string) => boolean | Promise<boolean>) | CorsOrigin[]
@@ -57,8 +59,8 @@ export interface RestApiAnyapiKnexPluginOptions extends RestApiKnexPluginOptions
   schemaCheckInterval?: number
 }
 export interface BulkOperationsPluginOptions {
+  // Entries one HTTP bulk request may carry (default 1000).
   maxBulkOperations?: number
-  defaultAtomic?: boolean
 }
 export interface LabelPluginOptions {
   preferNameFields?: string[]

package/types/resource-methods.d.ts

@@ -1,5 +1,6 @@
 import type { Knex } from 'knex'
 import type { ManagedTransactionParam } from './transactions.js'
+import type { DataAccessMethods } from './data-access-methods.js'
 import type {
   CollectionResult, DirectResourceId, InputResourceId, InputResourceIdentifier, ResourceFormat,
   SingleResourceResult, WriteResult, WriteReturning
@@ -24,10 +25,32 @@ export interface QueryParams extends SelectionParams {
   page?: PageParams
 }
 export type AggregateFunction = 'count' | 'countDistinct' | 'sum' | 'avg' | 'min' | 'max'
-// One function per measure; only count accepts '*'.
-export type AggregateMeasure = { count: string } | { [Function in Exclude<AggregateFunction, 'count'>]: { [Name in Function]: string } }[Exclude<AggregateFunction, 'count'>]
+type AggregateScalar = string | number | boolean | Date
+// A measure's condition: a value (null tests for null), a list (IN), or operators; every entry must hold.
+export type AggregateCondition = AggregateScalar | null | AggregateScalar[] | {
+  eq?: AggregateScalar | null
+  ne?: AggregateScalar | null
+  gt?: AggregateScalar
+  gte?: AggregateScalar
+  lt?: AggregateScalar
+  lte?: AggregateScalar
+  in?: AggregateScalar[]
+  notIn?: AggregateScalar[]
+}
+export type AggregateWhere = Record<string, AggregateCondition>
+// One function per measure; only count accepts '*'. where makes the measure conditional (CASE inside the function).
+export type AggregateMeasure = ({ count: string } | { [Function in Exclude<AggregateFunction, 'count'>]: { [Name in Function]: string } }[Exclude<AggregateFunction, 'count'>]) & { where?: AggregateWhere }
+// A date or dateTime field grouped by period; the group value is the period's first day, 'YYYY-MM-DD' (weeks start on Monday).
+export interface AggregateBucket {
+  field: string
+  bucket: 'day' | 'week' | 'month' | 'year'
+  // 'UTC' (default), a fixed offset such as '+10:00', or an IANA name (PostgreSQL; MySQL with time zone tables).
+  timezone?: string
+  // Output name; default the field name.
+  as?: string
+}
 export interface AggregateParams extends TransactionParam {
-  groupBy?: string[]
+  groupBy?: Array<string | AggregateBucket>
   measures: Record<string, AggregateMeasure>
   queryParams?: {
     filters?: Record<string, unknown>
@@ -89,7 +112,7 @@ export interface ResourceCoreMethods<
   DefaultFormat extends ResourceFormat = 'plain',
   DefaultReturning extends WriteReturning = 'full',
   Context extends object = object
-> {
+> extends DataAccessMethods<Fields, Input, Type, DefaultFormat, Context> {
   get<Format extends ResourceFormat = DefaultFormat>(
     params: ReadOptions<Format> & { id: DirectResourceId }, context?: Context
   ): Promise<SingleResourceResult<Format, Fields, Type>>

package/types/row-policy.d.ts

@@ -5,7 +5,10 @@ export interface RowPolicyParams<Context extends object = Record<string, unknown
   context: Context
   scopeName: string
   tableName?: string
+  // 'report', 'bulk-write', 'lock' and 'claim' join the read purposes of earlier releases.
   queryPurpose: string
+  // True only for a context made by createSystemContext.
+  system: boolean
   db?: StorageDatabase
   isAnyApi: boolean
   storageAdapter?: StorageAdapter | null

package/types/runtime.d.ts

@@ -33,10 +33,14 @@ export interface RuntimeArguments<Context extends object = Record<string, unknow
   runHooks(event: string, context?: Record<string, unknown>): Promise<boolean>
   /** Whether runHooks(event) for this resource, or for scope when given, would call any handler. */
   hasHooks(event: string, scope?: RuntimeResource): boolean
+  /** Handlers of these events that would run for this resource (or scope) without { batch: true }. */
+  perRecordHooks(events: readonly string[], scope?: RuntimeResource): Array<{ event: string; name: string }>
 }
 export type RuntimeMethod<Context extends object = Record<string, unknown>> = (args: RuntimeArguments<Context>) => unknown
 export type HookPlacement = { beforeFunction?: string; afterFunction?: never } | { beforeFunction?: never; afterFunction?: string }
-type HookDefinition<Handler> = Handler | (HookPlacement & { functionName?: string; handler: Handler })
+// batch: true marks a per-record handler that many-row operations may skip: its work
+// is done by a batch hook, or does not apply to them. Without it they refuse the resource.
+type HookDefinition<Handler> = Handler | (HookPlacement & { functionName?: string; batch?: boolean; handler: Handler })
 export type RuntimeHook<Context extends object = Record<string, unknown>> = HookDefinition<RuntimeMethod<Context>>
 export type RuntimeHooks<Context extends object = Record<string, unknown>> = {
   [Event in KnownHookName]?: HookDefinition<HookHandler<Event, Context>>
@@ -60,6 +64,8 @@ export interface RuntimeResourceOptions<Context extends object = Record<string,
   sortableFields?: string[]
   defaultSort?: string[]
   versionField?: string
+  // A stored integer that every library update of a row advances by one.
+  lockVersionField?: string
   rowPolicy?: ResourceRowPolicy<Context>
   autofilter?: ResourceAutoFilter<Context>
   indexes?: Array<{ name?: string; columns: string[]; unique?: boolean }>

package/docs/GUIDE/27-bulk-operations.md

@@ -1,277 +0,0 @@
----
-title: "Bulk operations"
-chapter: 27
-chapter_label: "27"
----
-
-# 27. Bulk operations
-
-`BulkOperationsPlugin` provides `bulkPost`, `bulkPatch` and `bulkDelete`. Entries
-run through their normal resource lifecycle, sequentially. A bulk request can
-reduce network overhead; it does not turn resource writes into one batched SQL
-statement or skip permissions, validation, setters and hooks.
-
-POST/PATCH use the same output-only `format` and `returning` options as individual writes.
-Results contain `meta`, optional indexed `errors`, and `data` for full/minimal
-responses. `returning: 'none'` omits data. DELETE returns its summary and deleted
-IDs in `meta.deleted`.
-
-## Runnable example
-
-Insert the following seven JavaScript blocks into the
-[starting script](03-running-example.md), after installing storage and
-before declaring resources or starting the server, on a fresh database. Later
-snippets in this guide are fragments illustrating existing application state.
-
-```javascript
-import { BulkOperationsPlugin } from 'json-rest-api/plugins/core/bulk-operations-plugin.js'
-
-await api.use(BulkOperationsPlugin, { maxBulkOperations: 100, defaultAtomic: true })
-await api.addResource('books', {
-  schema: { title: { type: 'string', required: true } }
-})
-await api.resources.books.createKnexTable()
-```
-
-```javascript
-const created = await api.resources.books.bulkPost({
-  data: [{ title: 'Alpha' }, { title: 'Beta' }], format: 'plain'
-})
-console.log(created.data, created.meta)
-```
-
-The two records are returned in input order. The summary is
-`{ total: 2, succeeded: 2, failed: 0, atomic: true }`.
-For JSON:API bulk creation, pass `document: { data: [...] }`, where each array
-entry is a JSON:API resource object with `type`, attributes and relationships.
-Supply either the plain `data` array or `document`, never both. Input selection
-does not determine the output format.
-
-```javascript
-const updated = await api.resources.books.bulkPatch({
-  operations: created.data.map(book => ({ id: book.id, data: { title: `${book.title} revised` } })),
-  format: 'plain', returning: 'minimal'
-})
-console.log(updated.data, updated.meta)
-```
-
-PATCH entries select input individually: `{ id, data: plainValues }` or
-`{ id, document: { data: resourceObject } }`. Each entry accepts exactly one input
-key; a batch may contain both kinds. `format` selects output for the batch.
-Minimal output contains identifiers.
-
-```javascript
-const partial = await api.resources.books.bulkPost({
-  data: [{ title: 'Gamma' }, {}], format: 'plain', atomic: false
-})
-console.log(partial.data, partial.errors, partial.meta)
-```
-
-Gamma is stored, while the second entry fails required-title validation. The
-summary reports one success and one failure; `errors[0].index` is 1. Successful
-data entries are compacted, so their array positions do not represent failed
-input slots. Use the indexed errors to identify rejected inputs.
-
-```javascript
-let atomicError
-try {
-  await api.resources.books.bulkPost({
-    data: [{ title: 'Not retained' }, {}], format: 'plain', atomic: true
-  })
-} catch (error) { atomicError = error }
-const afterAtomicFailure = await api.resources.books.query({ format: 'plain' })
-console.log(atomicError?.transactionOutcome, afterAtomicFailure.data.map(book => book.title))
-```
-
-The owned batch rejects with rolled-back outcome, and Not retained is absent.
-The earlier, separately completed calls remain stored.
-
-```javascript
-const gamma = partial.data[0]
-let managedError
-try {
-  await api.transaction(async transaction => {
-    await api.resources.books.bulkPatch({
-      operations: [{ id: gamma.id, data: { title: 'Pending title' } }],
-      format: 'plain', returning: 'none', atomic: true, transaction
-    })
-    throw new Error('Cancel this unit')
-  })
-} catch (error) { managedError = error }
-const afterManagedRollback = await api.resources.books.get({ id: gamma.id, format: 'plain' })
-console.log(managedError?.message, afterManagedRollback.title)
-```
-
-The outer callback rejection restores Gamma. The batch borrows the managed
-transaction and cannot independently commit its changes.
-
-```javascript
-const deleted = await api.resources.books.bulkDelete({ ids: created.data.map(book => book.id), atomic: true })
-const remaining = await api.resources.books.query({ format: 'plain' })
-console.log(deleted.meta, remaining.data)
-```
-
-The delete summary names the two deleted IDs. Gamma remains.
-
-## Configuration Options
-
-Pass these options directly to `api.use(BulkOperationsPlugin, options)`:
-
-| Option | Type | Default | Description |
-|--------|------|---------|-------------|
-| `maxBulkOperations` | positive safe integer | 100 | Maximum number of records that can be processed in a single request |
-| `defaultAtomic` | boolean | true | Whether operations are atomic (all-or-nothing) by default |
-
-Invalid values and unknown option names fail during installation. Remove
-`batchSize` and `enableOptimizations`: they did not provide SQL batching, and the
-disconnected optimization handler has been removed. Do not wrap options inside
-a `'bulk-operations'` key. See [the migration steps](33-migrating-to-v2.md#bulk-writes).
-
-## Failures and diagnostics
-
-Atomic failures preserve the original error if rollback also rejects. The
-outer batch attempts rollback once for an unfinished transaction it owns and stores
-secondary rollback errors in the supplied context's `cleanupErrors` array;
-`context.error` retains the original failure. Both diagnostic fields reset on
-the next bulk call. A rejected rollback does not confirm that data was restored.
-Managed completion follows the [transaction contract](19-managed-transactions.md).
-
-Child cleanup diagnostics are now available on the batch context, including
-warnings from successful entries. Each has a zero-based `bulkIndex` alongside
-its `phase`, original `error` and any file information. For example:
-
-```js
-const context = {};
-const result = await api.resources.books.bulkPatch({
-  operations: [{ id: '42', data: { title: 'Updated title' } }],
-  format: 'plain',
-  atomic: false
-}, context);
-
-for (const diagnostic of context.cleanupErrors || []) {
-  console.error(diagnostic.bulkIndex, diagnostic.phase, diagnostic.error);
-}
-```
-
-The batch response keeps its existing indexed primary errors; secondary cleanup
-errors are retained on the context. `meta.failed` counts rejected calls, not
-rolled-back writes: an `afterCommit` hook can fail after its data is stored.
-
-Remaining child uploads are retained in `context.fileHandlingUploads`, also
-tagged with `bulkIndex` and retaining their storage and transaction references.
-They can include a failed deletion or committed files whose tracking-release
-hook did not run. Do not delete or retry them solely because they are tracked.
-Reusing the batch context clears old error diagnostics and keeps unresolved
-upload tracking without copying it into new children. Write errors expose
-`transactionOutcome`; managed completion-chain diagnostics also identify
-`operationIndex`, `scopeName` and `method`. Broader integration remains in progress.
-
-## Version conditions
-
-For a resource with an explicit stored `versionField`, bulk PATCH and DELETE
-accept `expectedVersions`: one revision token for each entry, in the same order
-as `operations` or `ids`. Omit the entire array for unconditional writes. Each
-token must be a non-empty string of at most 128 characters; null entries and
-partially conditional arrays are not supported. The library validates the
-array before starting any child operation, including in non-atomic mode.
-
-```js
-const current = await api.resources.books.get({ id: '42', format: 'plain' })
-await api.resources.books.bulkPatch({
-  operations: [{ id: current.id, data: { title: 'Updated title' } }],
-  expectedVersions: [current.revision],
-  format: 'plain'
-})
-```
-
-Use the revision field selected by your resource configuration. It belongs in
-`expectedVersions`, not in the submitted attributes. Successful updates rotate
-the revision even when no conditions were supplied. Read full responses or
-fetch the record again to obtain its new revision.
-
-A stale condition raises `REST_API_VERSION_CONFLICT`. An owned atomic batch
-rolls back all its changes. A non-atomic batch retains successful children and
-reports the failed child's index and transaction outcome in `errors`. Caller
-transactions retain their normal ownership rules below. Missing or inaccessible
-rows retain the single-write not-found behavior.
-
-HTTP bulk PATCH/DELETE use the same `expectedVersions` property in the request
-body, alongside `operations` or `ids`. Atomic version conflicts map to HTTP 409;
-malformed condition arrays map to 422. These are body conditions, not HTTP
-`If-Match` validators. Bulk creation rejects revision conditions, and all bulk
-methods reject the singular `expectedVersion` option.
-
-## Transaction ownership
-
-Pass `transaction` in the first argument to bulkPost, bulkPatch or bulkDelete,
-with `atomic: true`. Each entry uses that same transaction, including its
-relationship changes and full-response reads. The bulk call neither commits nor
-rolls it back. Other calls and raw SQL can join the same transaction.
-
-```js
-await api.transaction(async transaction => {
-  return api.resources.books.bulkPatch({
-    operations: [{ id: '42', data: { title: 'Updated title' } }],
-    format: 'plain',
-    returning: 'minimal',
-    atomic: true,
-    transaction
-  })
-})
-```
-
-The managed helper rolls back the whole unit after callback rejection or a
-participating write/observed SQL failure, even when caught. A rejected batch can
-leave changes pending until the helper finishes; its individual operations do
-not complete the transaction or create savepoints. Raw transactions and child
-savepoints cannot be passed to library writes. Raw SQL can join the managed
-callback through its actual Knex handle.
-
-Without a supplied transaction, an atomic batch owns one transaction for all
-entries; a non-atomic batch lets each entry own its transaction. Passing a
-transaction with `atomic: false` rejects before any child or SQL runs. This also
-applies when `defaultAtomic` is false: explicitly select `atomic: true` to join
-an outer transaction. A completed transaction rejects through the normal write
-path and is never silently replaced with a new one.
-
-Managed completion defers enlisted completion chains to the owner. See
-[managed transactions](19-managed-transactions.md) and
-[transaction outcomes](20-transaction-outcomes.md) for file/event integration,
-completion failures and uncertain outcomes.
-
-## HTTP API Usage
-
-Express and Fastify expose bulk endpoints. Install the connector and bulk
-plugin **before declaring resources**, then mount/start the application.
-Authenticated transport context reaches every ordinary resource write and its
-permission checks. HTTP always selects JSON:API/full responses: POST returns
-201, PATCH and DELETE return 200 with the batch summary. `atomic` query values
-must be exactly `true` or `false`; malformed values produce 422 without writes.
-The optional plugin reserves `/RESOURCE/bulk` for these methods, including when
-the resource accepts opaque IDs. This bulk protocol is not an implementation of
-the JSON:API Atomic Operations extension.
-
-
-The bulk HTTP request bodies are:
-
-| Method and path | Body fields |
-| --- | --- |
-| `POST /api/books/bulk` | `data`: array of JSON:API resource objects |
-| `PATCH /api/books/bulk` | `operations`: array of `{ id, data }`, where `data` is a resource object |
-| `DELETE /api/books/bulk` | `ids`: array of resource IDs |
-
-For example:
-
-```json
-{
-  "operations": [
-    { "id": "1", "data": { "type": "books", "id": "1", "attributes": { "title": "Revised" } } }
-  ]
-}
-```
-
-Select `?atomic=false` for independent child transactions, or omit it for the
-configured default. Non-atomic error summaries require application handling;
-a successful HTTP status does not mean every child call succeeded. In
-particular, inspect each error's transaction outcome before retrying a mutation
-that may already have committed. See [transaction outcomes](20-transaction-outcomes.md).

package/types/bulk-methods.d.ts

@@ -1,63 +0,0 @@
-import type { ManagedTransaction } from './transactions.js'
-import type { TransactionOutcome } from './errors.js'
-import type { DirectResourceId, InputResourceId, JsonApiResource, PlainResource, ResourceFormat, ResourceIdentifier, WriteReturning } from './representations.js'
-import type { JsonApiWriteDocument, RemovedResourceOptions, ResourceWriteInput, WriteOptions } from './resource-methods.js'
-
-export type BulkTransactionOptions<DefaultAtomic extends boolean = true> =
-  { atomic: true; transaction?: ManagedTransaction } |
-  { atomic: false; transaction?: never } |
-  { atomic?: undefined; transaction?: DefaultAtomic extends true ? ManagedTransaction : never }
-export interface BulkError {
-  index: number
-  id?: DirectResourceId
-  status: 'error'
-  error: { code: unknown; message: string; details?: unknown; transactionOutcome: TransactionOutcome }
-}
-export interface BulkMeta {
-  total: number
-  succeeded: number
-  failed: number
-  atomic: boolean
-}
-export type BulkWriteResult<Format extends ResourceFormat, Returning extends WriteReturning, Fields extends object, Type extends string> =
-  { meta: BulkMeta; errors?: BulkError[] } & (Returning extends 'none'
-    ? { data?: never }
-    : { data: Array<Returning extends 'minimal' ? ResourceIdentifier<Type> : Format extends 'plain' ? PlainResource<Fields> : JsonApiResource<Fields, Type>> })
-export interface BulkDeleteResult {
-  meta: BulkMeta & { deleted: DirectResourceId[] }
-  errors?: BulkError[]
-}
-export type BulkPostInput<Input extends object, Type extends string> =
-  { data: Array<Partial<Input> & { id?: InputResourceId }>; document?: never } |
-  { data?: never; document: Omit<JsonApiWriteDocument<Input, Type>, 'data'> & { data: JsonApiWriteDocument<Input, Type>['data'][] } }
-export type BulkPatchInput<Input extends object, Type extends string> = {
-  id: DirectResourceId
-} & ResourceWriteInput<Input, Type>
-export interface BulkResourceMethods<
-  Fields extends object = Record<string, unknown>, Input extends object = Fields,
-  Type extends string = string, DefaultFormat extends ResourceFormat = 'plain',
-  DefaultReturning extends WriteReturning = 'full', DefaultAtomic extends boolean = true,
-  Context extends object = object
-> {
-  bulkPost<Format extends ResourceFormat = DefaultFormat, Returning extends WriteReturning = DefaultReturning>(
-    params: Omit<WriteOptions<Format, Returning>, 'queryParams'> & BulkTransactionOptions<DefaultAtomic> & BulkPostInput<Input, Type> & {
-      expectedVersion?: never
-      expectedVersions?: never
-    }, context?: Context
-  ): Promise<BulkWriteResult<Format, Returning, Fields, Type>>
-  bulkPatch<Format extends ResourceFormat = DefaultFormat, Returning extends WriteReturning = DefaultReturning>(
-    params: Omit<WriteOptions<Format, Returning>, 'queryParams'> & BulkTransactionOptions<DefaultAtomic> & {
-      operations: BulkPatchInput<Input, Type>[]
-      expectedVersion?: never
-      expectedVersions?: string[]
-    }, context?: Context
-  ): Promise<BulkWriteResult<Format, Returning, Fields, Type>>
-  bulkDelete(
-    params: RemovedResourceOptions & BulkTransactionOptions<DefaultAtomic> & {
-      ids: DirectResourceId[]
-      format?: ResourceFormat
-      expectedVersion?: never
-      expectedVersions?: string[]
-    }, context?: Context
-  ): Promise<BulkDeleteResult>
-}