@type t() :: %Ash.Reactor.Dsl.BulkUpdate{
  __identifier__: any(),
  action: atom(),
  action_step?: true,
  actor: [Ash.Reactor.Dsl.Actor.t()],
  allow_stream_with: :keyset | :offset | :full_read,
  assume_casted?: boolean(),
  async?: boolean(),
  atomic_update: %{optional(atom()) => Ash.Expr.t()},
  authorize?: boolean() | nil,
  authorize_changeset_with: :filter | :error,
  authorize_query?: boolean(),
  authorize_query_with: :filter | :error,
  batch_size: nil | pos_integer(),
  description: String.t() | nil,
  domain: Ash.Domain.t(),
  filter:
    %{
      optional(String.t()) => %{
        required(String.t()) => String.t() | number() | boolean()
      }
    }
    | Keyword.t(Keyword.t(String.t() | number() | boolean())),
  initial: Reactor.Template.t(),
  inputs: [Ash.Reactor.Dsl.Inputs.t()],
  load: [atom()],
  lock: nil | Ash.DataLayer.lock_type(),
  max_concurrency: non_neg_integer(),
  name: atom(),
  notification_metadata: map() | Reactor.Template.t(),
  notify?: boolean(),
  page: Keyword.t(),
  read_action: atom(),
  resource: module(),
  return_errors?: boolean(),
  return_records?: boolean(),
  return_stream?: boolean(),
  reuse_values?: boolean(),
  rollback_on_error?: boolean(),
  select: [atom()],
  skip_unknown_inputs: [atom() | String.t()],
  sorted?: boolean(),
  stop_on_error?: boolean(),
  strategy: :atomic | :atomic_batches | :stream,
  stream_batch_size: nil | pos_integer(),
  stream_with: nil | :keyset | :offset | :full_read,
  success_state: :success | :partial_success,
  tenant: [Ash.Reactor.Dsl.Tenant.t()],
  timeout: nil | timeout(),
  transaction: :all | :batch | false,
  transform: term(),
  type: :bulk_create,
  undo: :never,
  undo_action: nil,
  wait_for: term()
}