action_figure 0.5.0 → 0.6.0

data/docs/custom-formatters.md

@@ -11,7 +11,7 @@ A formatter is a module that includes `ActionFigure::Formatter` and defines meth
 Including `ActionFigure::Formatter` gives you:
 
 - A default `NoContent` implementation that returns `{ status: :no_content }`.
-- A contract enforced at registration time: your module **must** define all 6 required methods.
+- A contract enforced at registration time: your module **must** define all 8 required methods.
 
 The required methods are:
 
@@ -23,6 +23,8 @@ The required methods are:
 | `UnprocessableContent` | Validation or schema rule failure          |
 | `NotFound`             | Resource not found                           |
 | `Forbidden`            | Authorization failure                        |
+| `Conflict`             | Resource state conflict or duplicate         |
+| `PaymentRequired`      | Business billing or quota constraint         |
 
 `NoContent` is provided by the base module and does not need to be defined, but you can override it if your format requires a different shape.
 
@@ -63,10 +65,18 @@ module WrappedFormatter
   def Forbidden(errors:)
     { json: { data: nil, errors: errors, status: "error" }, status: :forbidden }
   end
+
+  def Conflict(errors:)
+    { json: { data: nil, errors: errors, status: "error" }, status: :conflict }
+  end
+
+  def PaymentRequired(errors:)
+    { json: { data: nil, errors: errors, status: "error" }, status: :payment_required }
+  end
 end
 ```
 
-All 6 required methods are defined. Success methods accept `resource:` and optionally `meta:`, while failure methods accept `errors:`. The `NoContent` method is inherited from the base `ActionFigure::Formatter` module and returns `{ status: :no_content }` with no JSON body -- override it if your format requires a different shape.
+All 8 required methods are defined. Success methods accept `resource:` and optionally `meta:`, while failure methods accept `errors:`. The `NoContent` method is inherited from the base `ActionFigure::Formatter` module and returns `{ status: :no_content }` with no JSON body -- override it if your format requires a different shape.
 
 ## Registering Your Formatter
 
@@ -103,7 +113,7 @@ Registration is not just bookkeeping -- ActionFigure validates every formatter m
 
 ```ruby
 ActionFigure::Formatter::REQUIRED_METHODS
-# => [:Ok, :Created, :Accepted, :UnprocessableContent, :NotFound, :Forbidden]
+# => [:Ok, :Created, :Accepted, :UnprocessableContent, :NotFound, :Forbidden, :Conflict, :PaymentRequired]
 ```
 
 If any required method is missing, registration raises an `ArgumentError` that lists exactly which methods are absent:
@@ -119,7 +129,7 @@ end
 
 ActionFigure.register_formatter(incomplete: IncompleteFormatter)
 # => ArgumentError: IncompleteFormatter is missing formatter methods: Created, Accepted,
-#    UnprocessableContent, NotFound, Forbidden
+#    UnprocessableContent, NotFound, Forbidden, Conflict, PaymentRequired
 ```
 
 Validation is **atomic** when registering multiple formatters at once. If any single module in the batch fails validation, none of them are registered -- this ensures your registry always remains in a consistent state.

data/docs/response-formatters.md

@@ -47,7 +47,7 @@ end
 
 ## Response Helpers
 
-Every formatter implements the same seven response helpers. Six return a hash with `:json` and `:status` keys. `NoContent` returns only `:status`.
+Every formatter implements the same nine response helpers. Eight return a hash with `:json` and `:status` keys. `NoContent` returns only `:status`.
 
 | Helper                          | HTTP Status              | When to Use                                      |
 |---------------------------------|--------------------------|--------------------------------------------------|
@@ -55,9 +55,11 @@ Every formatter implements the same seven response helpers. Six return a hash wi
 | `Created(resource:, meta: nil)` | `201 Created`            | Successful resource creation                     |
 | `Accepted(resource: nil, meta: nil)` | `202 Accepted`      | Request accepted for background processing       |
 | `NoContent()`                   | `204 No Content`         | Successful delete or action with no response body|
-| `UnprocessableContent(errors:)` | `422 Unprocessable Content` | Validation failures                           |
-| `NotFound(errors:)`             | `404 Not Found`          | Resource not found                               |
+| `PaymentRequired(errors:)`      | `402 Payment Required`   | Business billing or quota constraint             |
 | `Forbidden(errors:)`            | `403 Forbidden`          | Authorization failure                            |
+| `NotFound(errors:)`             | `404 Not Found`          | Resource not found                               |
+| `Conflict(errors:)`             | `409 Conflict`           | Resource state conflict or duplicate             |
+| `UnprocessableContent(errors:)` | `422 Unprocessable Content` | Validation failures                           |
 
 `NoContent` is shared across all formatters and is defined in the base `Formatter` module. It returns `{ status: :no_content }` with no JSON body.
 
@@ -227,6 +229,41 @@ end
 }
 ```
 
+**`Conflict`:**
+
+```ruby
+def call(params:)
+  return Conflict(errors: { email: ["already registered"] }) if User.exists?(email: params[:email])
+  user = User.create(params)
+  Created(resource: user)
+end
+```
+
+```json
+{
+  "errors": {
+    "email": ["already registered"]
+  }
+}
+```
+
+**`PaymentRequired`:**
+
+```ruby
+def call(params:, current_user:)
+  return PaymentRequired(errors: { base: ["subscription expired"] }) if current_user.subscription_expired?
+  Ok(resource: Dashboard.for(current_user))
+end
+```
+
+```json
+{
+  "errors": {
+    "base": ["subscription expired"]
+  }
+}
+```
+
 ## JSend Format
 
 The JSend formatter wraps responses in the [JSend specification](https://github.com/omniti-labs/jsend) envelope.
@@ -382,6 +419,43 @@ end
 }
 ```
 
+**`Conflict`:**
+
+```ruby
+def call(params:)
+  return Conflict(errors: { email: ["already registered"] }) if User.exists?(email: params[:email])
+  user = User.create(params)
+  Created(resource: user)
+end
+```
+
+```json
+{
+  "status": "fail",
+  "data": {
+    "email": ["already registered"]
+  }
+}
+```
+
+**`PaymentRequired`:**
+
+```ruby
+def call(params:, current_user:)
+  return PaymentRequired(errors: { base: ["subscription expired"] }) if current_user.subscription_expired?
+  Ok(resource: Dashboard.for(current_user))
+end
+```
+
+```json
+{
+  "status": "fail",
+  "data": {
+    "base": ["subscription expired"]
+  }
+}
+```
+
 ## Wrapped Format
 
 The Wrapped formatter places every response in a uniform `{ data:, errors:, status: }` envelope. Success responses use `"status": "success"` and failure responses use `"status": "error"`.
@@ -543,6 +617,45 @@ end
 }
 ```
 
+**`Conflict`:**
+
+```ruby
+def call(params:)
+  return Conflict(errors: { email: ["already registered"] }) if User.exists?(email: params[:email])
+  user = User.create(params)
+  Created(resource: user)
+end
+```
+
+```json
+{
+  "data": null,
+  "errors": {
+    "email": ["already registered"]
+  },
+  "status": "error"
+}
+```
+
+**`PaymentRequired`:**
+
+```ruby
+def call(params:, current_user:)
+  return PaymentRequired(errors: { base: ["subscription expired"] }) if current_user.subscription_expired?
+  Ok(resource: Dashboard.for(current_user))
+end
+```
+
+```json
+{
+  "data": null,
+  "errors": {
+    "base": ["subscription expired"]
+  },
+  "status": "error"
+}
+```
+
 ## JSON:API Format
 
 The JSON:API formatter structures responses according to the [JSON:API specification](https://jsonapi.org/).
@@ -739,6 +852,49 @@ end
 }
 ```
 
+**`Conflict`:**
+
+```ruby
+def call(params:)
+  return Conflict(errors: { email: ["already registered"] }) if User.exists?(email: params[:email])
+  user = User.create(params)
+  Created(resource: user)
+end
+```
+
+```json
+{
+  "errors": [
+    {
+      "status": "409",
+      "detail": "already registered",
+      "source": { "pointer": "/data/attributes/email" }
+    }
+  ]
+}
+```
+
+**`PaymentRequired`:**
+
+```ruby
+def call(params:, current_user:)
+  return PaymentRequired(errors: { base: ["subscription expired"] }) if current_user.subscription_expired?
+  Ok(resource: Dashboard.for(current_user))
+end
+```
+
+```json
+{
+  "errors": [
+    {
+      "status": "402",
+      "detail": "subscription expired",
+      "source": { "pointer": "/data" }
+    }
+  ]
+}
+```
+
 ## ActiveRecord Serialization (JSON:API)
 
 The JSON:API formatter includes automatic serialization for ActiveRecord objects via the `Resource` class.

data/docs/status-codes.md

@@ -0,0 +1,35 @@
+# HTTP 4xx Status Codes
+
+Rows in **bold** are status codes with built-in formatter methods — action classes can return these directly via helpers like `NotFound(errors:)` or `Conflict(errors:)`. All other 4xx codes are handled outside action classes by the perimeter (middleware, router, Rack, or infrastructure).
+
+| Status | Name                             | Category  | Responsibility  | Description / Logic Example                                          |
+|--------|----------------------------------|-----------|-----------------|----------------------------------------------------------------------|
+| 400    | Bad Request                      | Perimeter | Controller/Rack | Malformed syntax or missing top-level structure.                     |
+| 401    | Unauthorized                     | Perimeter | Middleware/Auth  | Authentication failed or missing credentials.                        |
+| **402** | **Payment Required**            | **Domain** | **Action Class** | **Business state: "Subscription overdue" or "Quota exceeded."**     |
+| **403** | **Forbidden**                   | **Domain** | **Action Class** | **Authenticated, but lacks permissions for this specific task.**    |
+| **404** | **Not Found**                   | **Domain** | **Action Class** | **The requested resource ID does not exist in the database.**       |
+| 405    | Method Not Allowed               | Perimeter | Rails Router     | Sending a POST to a GET route.                                       |
+| 406    | Not Acceptable                   | Perimeter | Controller       | Client requested a format (e.g., XML) the server won't provide.     |
+| 407    | Proxy Auth Required              | Perimeter | Infrastructure   | Similar to 401, but for a proxy server.                              |
+| 408    | Request Timeout                  | Perimeter | Server/Nginx     | The client took too long to send the request.                        |
+| **409** | **Conflict**                    | **Domain** | **Action Class** | **Resource already exists, or the state is in conflict.**           |
+| 410    | Gone                             | Domain    | Action Class     | The resource is permanently deleted (not just 404).                  |
+| 411    | Length Required                  | Perimeter | Server/Rack      | The request didn't specify a Content-Length.                         |
+| 412    | Precondition Failed              | Perimeter | Controller/Rack  | If-Match headers don't match (usually for caching).                  |
+| 413    | Payload Too Large                | Perimeter | Server/Nginx     | The request body is bigger than the server allows.                   |
+| 414    | URI Too Long                     | Perimeter | Server/Nginx     | The URL is too long for the server to process.                       |
+| 415    | Unsupported Media Type           | Perimeter | Controller       | Sending text/plain instead of application/json.                      |
+| 416    | Range Not Satisfiable            | Perimeter | Server/Rack      | Invalid Range header (usually for file downloads).                   |
+| 417    | Expectation Failed               | Perimeter | Server           | The server can't meet the Expect header requirements.                |
+| 418    | I'm a teapot                     | Domain    | Action Class     | An IETF April Fools joke (rarely used in production).                |
+| 421    | Misdirected Request              | Perimeter | Infrastructure   | The server can't produce a response for this connection.             |
+| **422** | **Unprocessable Content**       | **Domain** | **Action Class** | **Semantic errors (validation, business rules).**                   |
+| 423    | Locked                           | Domain    | Action Class     | The resource is being accessed by another process.                   |
+| 424    | Failed Dependency                | Domain    | Action Class     | The request failed due to a failure of a previous request.           |
+| 425    | Too Early                        | Perimeter | Server/Rack      | The server is unwilling to process a request that might be replayed. |
+| 426    | Upgrade Required                 | Perimeter | Server/Rack      | The client must switch to a different protocol (e.g., TLS).          |
+| 428    | Precondition Required            | Perimeter | Controller/Rack  | The server requires the request to be conditional.                   |
+| 429    | Too Many Requests                | Perimeter | Rack::Attack     | Infrastructure-level rate limiting (IP-based, etc.).                 |
+| 431    | Request Header Fields Too Large  | Perimeter | Server/Rack      | HTTP headers are too large.                                          |
+| 451    | Unavailable For Legal Reasons    | Domain    | Action Class     | Resource censored/blocked for legal/regional reasons.                |

data/docs/testing.md

@@ -33,6 +33,8 @@ end
 | `assert_UnprocessableContent(result)` | `:unprocessable_content` |
 | `assert_NotFound(result)`             | `:not_found`             |
 | `assert_Forbidden(result)`            | `:forbidden`             |
+| `assert_Conflict(result)`             | `:conflict`              |
+| `assert_PaymentRequired(result)`      | `:payment_required`      |
 
 All assertions accept an optional second argument for a custom failure message:
 
@@ -70,6 +72,8 @@ require "action_figure/testing/rspec"
 | `be_UnprocessableContent` | `:unprocessable_content` |
 | `be_NotFound`             | `:not_found`             |
 | `be_Forbidden`            | `:forbidden`             |
+| `be_Conflict`             | `:conflict`              |
+| `be_PaymentRequired`      | `:payment_required`      |
 
 Matchers support negation:
 
@@ -101,7 +105,7 @@ class Users::CreateActionTest < Minitest::Test
   include ActionFigure::Testing::Minitest
 
   def test_creates_a_user
-    result = Users::CreateAction.call(params: { email: "jane@example.com", name: "Jane" })
+    result = Users::CreateAction.create(params: { email: "jane@example.com", name: "Jane" })
 
     assert_Ok(result)
     assert_equal "jane@example.com", result[:json][:data][:email]
@@ -119,7 +123,7 @@ class Users::CreateActionTest < Minitest::Test
   include ActionFigure::Testing::Minitest
 
   def test_rejects_missing_email
-    result = Users::CreateAction.call(params: { name: "Jane" })
+    result = Users::CreateAction.create(params: { name: "Jane" })
 
     assert_UnprocessableContent(result)
     assert_includes result[:json][:data][:email], "is missing"
@@ -137,7 +141,7 @@ class Posts::CreateActionTest < Minitest::Test
 
   def test_creates_a_post_for_the_current_user
     user = users(:jane)
-    result = Posts::CreateAction.call(params: { title: "Hello", body: "World" }, current_user: user)
+    result = Posts::CreateAction.create(params: { title: "Hello", body: "World" }, current_user: user)
 
     assert_Created(result)
     assert_equal user.id, result[:json][:data][:author_id]
@@ -145,9 +149,9 @@ class Posts::CreateActionTest < Minitest::Test
 end
 ```
 
-### Testing a Custom Entry Point
+### Testing an Action with a Named Method
 
-When an action defines a custom class method (e.g., `.search`) instead of the default `.call`, call it by that name:
+Call the action using its discovered method name:
 
 ```ruby
 class Products::SearchActionTest < Minitest::Test
@@ -156,8 +160,6 @@ class Products::SearchActionTest < Minitest::Test
   # class SearchAction
   #   include ActionFigure[:jsend]
   #
-  #   entry_point :search
-  #
   #   params_schema do
   #     required(:query).filled(:string)
   #   end
@@ -187,14 +189,14 @@ class Sessions::DestroyActionTest < Minitest::Test
   # class Sessions::DestroyAction
   #   include ActionFigure[:jsend]
   #
-  #   def call(session:)
+  #   def destroy(session:)
   #     session.destroy!
   #     NoContent()
   #   end
   # end
   def test_destroys_the_session
     session = sessions(:active)
-    result = Sessions::DestroyAction.call(session: session)
+    result = Sessions::DestroyAction.destroy(session: session)
 
     assert_NoContent(result)
   end
@@ -224,7 +226,7 @@ result.failure?      # => true
 result.errors.to_h   # => { email: ["must be filled"] }
 ```
 
-This runs both the schema and any `rules` defined on the action -- the same validation pipeline that `.call` uses, without the side effects.
+This runs both the schema and any `rules` defined on the action -- the same validation pipeline that the class-level trigger uses, without the side effects.
 
 Actions that do not define a `params_schema` return `nil` from `.contract`.
 

data/docs/validation.md

@@ -9,7 +9,7 @@ The two layers are:
 1. **`params_schema`** -- structural validation and type coercion (powered by dry-schema)
 2. **`rules`** -- validation rules that run only after the schema passes
 
-If `params:` is not passed to the action at all, validation is skipped entirely and `#call` is invoked directly. If `params:` is passed but no `params_schema` is defined, an `ArgumentError` is raised immediately.
+If no `params_schema` is defined, `params:` passes through to your `#call` method as-is — no validation, no coercion, no stripping of extra keys. This lets you rely on upstream validation (e.g., Rack middleware like `committee`) while still using ActionFigure for orchestration and response formatting.
 
 ---
 

data/lib/action_figure/core.rb

@@ -36,13 +36,19 @@ module ActionFigure
       end
     end
 
-    # DSL class methods extended into action classes: params_schema, rules, entry_point, call.
+    # DSL class methods extended into action classes: params_schema, rules, entry_point.
     #
     # Note: ActionFigure does not support class inheritance. +params_schema+, +rules+, and
     # +entry_point+ store state in class-level instance variables that are not inherited by
     # subclasses. Define each action class independently.
     module ClassMethods
       def params_schema(&block)
+        if @params_schema_block && @rules_block
+          raise ArgumentError,
+                "params_schema already defined with rules — " \
+                "redefining it would silently drop the existing rules block"
+        end
+
         @params_schema_block = block
         @contract = nil
       end
@@ -64,6 +70,7 @@ module ActionFigure
                 "each action class may declare only one entry point"
         end
 
+        @explicit_entry_point = true
         @entry_point_name = name
         singleton_class.define_method(name) do |**kwargs|
           notify { new.validated_call(**kwargs) }
@@ -78,14 +85,6 @@ module ActionFigure
         value == :_unset ? @api_version : (@api_version = value)
       end
 
-      def call(**)
-        if @entry_point_name
-          raise NoMethodError, "undefined method 'call' for #{self} (use '#{@entry_point_name}' instead)"
-        end
-
-        notify { new.validated_call(**) }
-      end
-
       def contract
         return nil unless @params_schema_block
 
@@ -99,6 +98,27 @@ module ActionFigure
         yield
       end
 
+      def method_added(name)
+        return if @explicit_entry_point
+        return unless public_method_defined?(name)
+        return unless instance_method(name).owner == self
+
+        if @entry_point_name
+          raise IndeterminantEntryPointError,
+                "Multiple public methods defined in #{self}: " \
+                ":#{@entry_point_name} and :#{name}. " \
+                "Either make one private or declare " \
+                "`entry_point :#{@entry_point_name}` to disambiguate."
+        end
+
+        @entry_point_name = name
+        singleton_class.define_method(name) do |**kwargs|
+          notify { new.validated_call(**kwargs) }
+        end
+      ensure
+        super
+      end
+
       def build_contract
         schema_block = @params_schema_block
         rules_block = @rules_block
@@ -115,7 +135,7 @@ module ActionFigure
     end
 
     def entry_point_name
-      self.class.entry_point_name || :call
+      self.class.entry_point_name
     end
 
     def contract
@@ -123,12 +143,12 @@ module ActionFigure
     end
 
     def validated_call(**kwargs)
-      raise ArgumentError, "params: passed but no params_schema defined" if kwargs.key?(:params) && !contract
+      kwargs = normalize_params(kwargs)
 
-      if kwargs.key?(:params)
-        call_with_params(**kwargs)
+      if contract && kwargs.key?(:params)
+        validate_and_call(**kwargs)
       else
-        call_without_params(**kwargs)
+        public_send(entry_point_name, **kwargs)
       end
     end
 
@@ -149,18 +169,22 @@ module ActionFigure
 
     private
 
-    def call_with_params(**kwargs)
-      raw_params = kwargs[:params]
-      raw_params = raw_params.to_unsafe_h if raw_params.respond_to?(:to_unsafe_h)
+    def normalize_params(kwargs)
+      raw = kwargs[:params]
+      return kwargs unless raw.respond_to?(:to_unsafe_h)
+
+      kwargs.merge(params: raw.to_unsafe_h)
+    end
 
-      result = contract.call(raw_params)
+    def validate_and_call(**kwargs)
+      result = contract.call(kwargs[:params])
 
       return UnprocessableContent(errors: result.errors.to_h) if result.failure?
 
-      extra_params_error = check_extra_params(raw_params, result)
+      extra_params_error = check_extra_params(kwargs[:params], result)
       return extra_params_error if extra_params_error
 
-      public_send(entry_point_name, **kwargs, params: result.to_h)
+      public_send(entry_point_name, **kwargs.except(:params), params: result.to_h)
     end
 
     def check_extra_params(raw_params, result)
@@ -172,9 +196,5 @@ module ActionFigure
       errors = extra_keys.to_h { |k| [k, ["is not allowed"]] }
       UnprocessableContent(errors: errors)
     end
-
-    def call_without_params(**)
-      public_send(entry_point_name, **)
-    end
   end
 end

data/lib/action_figure/format_registry.rb

@@ -1,16 +1,18 @@
 # frozen_string_literal: true
 
+require "concurrent/map"
+
 module ActionFigure
   # Provides formatter registration and lookup for ActionFigure.
   module FormatRegistry
     # Stores the mapping of format names to formatter modules.
     class Formats
       def initialize
-        @formats = {}
+        @formats = Concurrent::Map.new
       end
 
       def register_formatter(**formatters)
-        @formats.merge!(formatters)
+        formatters.each { |name, mod| @formats[name] = mod }
       end
 
       def fetch(name)

data/lib/action_figure/formatter.rb

@@ -5,7 +5,7 @@ module ActionFigure
   # Include this in your formatter module to get a NoContent default
   # and to signal that your module implements the formatter interface.
   module Formatter
-    REQUIRED_METHODS = %i[Ok Created Accepted UnprocessableContent NotFound Forbidden].freeze
+    REQUIRED_METHODS = %i[Ok Created Accepted UnprocessableContent NotFound Forbidden Conflict PaymentRequired].freeze
 
     def NoContent
       { status: :no_content }

data/lib/action_figure/formatters/default.rb

@@ -3,23 +3,25 @@
 module ActionFigure
   module Formatters
     # Implements Rails-style response helpers for use in action classes.
-    # Resource is the top-level JSON on success; errors live under an "errors" key on failure.
+    # Success responses use a { data: } envelope; errors live under an "errors" key on failure.
     module Default
       include ActionFigure::Formatter
 
       def Ok(resource:, meta: nil)
-        body = meta ? { data: resource, meta: meta } : resource
+        body = { data: resource }
+        body[:meta] = meta if meta
         { json: body, status: :ok }
       end
 
       def Created(resource:, meta: nil)
-        body = meta ? { data: resource, meta: meta } : resource
+        body = { data: resource }
+        body[:meta] = meta if meta
         { json: body, status: :created }
       end
 
       def Accepted(resource: nil, meta: nil)
-        body = resource.nil? ? {} : resource
-        body = { data: body, meta: meta } if meta
+        body = { data: resource }
+        body[:meta] = meta if meta
         { json: body, status: :accepted }
       end
 
@@ -34,6 +36,14 @@ module ActionFigure
       def Forbidden(errors:)
         { json: { errors: errors }, status: :forbidden }
       end
+
+      def Conflict(errors:)
+        { json: { errors: errors }, status: :conflict }
+      end
+
+      def PaymentRequired(errors:)
+        { json: { errors: errors }, status: :payment_required }
+      end
     end
   end
 end

data/lib/action_figure/formatters/jsend.rb

@@ -36,6 +36,14 @@ module ActionFigure
       def Forbidden(errors:)
         { json: { status: "fail", data: errors }, status: :forbidden }
       end
+
+      def Conflict(errors:)
+        { json: { status: "fail", data: errors }, status: :conflict }
+      end
+
+      def PaymentRequired(errors:)
+        { json: { status: "fail", data: errors }, status: :payment_required }
+      end
     end
   end
 end

data/lib/action_figure/formatters/json_api/resource.rb

@@ -6,13 +6,11 @@ module ActionFigure
       # Simple resource serialization
       class Resource
         def self.serialize(resource)
-          if resource.is_a?(Hash)
-            resource
-          elsif resource.respond_to?(:attributes)
+          if resource.respond_to?(:attributes)
             serialize_one(resource)
-          elsif resource.respond_to?(:each)
+          elsif !resource.is_a?(Hash) && resource.respond_to?(:each)
             resource.map { |r| serialize(r) }
-          else # rubocop:disable Lint/DuplicateBranch
+          else
             resource
           end
         end

data/lib/action_figure/formatters/json_api.rb

@@ -38,6 +38,14 @@ module ActionFigure
         { json: { errors: convert_errors(errors, "403") }, status: :forbidden }
       end
 
+      def Conflict(errors:)
+        { json: { errors: convert_errors(errors, "409") }, status: :conflict }
+      end
+
+      def PaymentRequired(errors:)
+        { json: { errors: convert_errors(errors, "402") }, status: :payment_required }
+      end
+
       private
 
       def convert_errors(errors, status)

data/lib/action_figure/formatters/wrapped.rb

@@ -36,6 +36,14 @@ module ActionFigure
       def Forbidden(errors:)
         { json: { data: nil, errors: errors, status: "error" }, status: :forbidden }
       end
+
+      def Conflict(errors:)
+        { json: { data: nil, errors: errors, status: "error" }, status: :conflict }
+      end
+
+      def PaymentRequired(errors:)
+        { json: { data: nil, errors: errors, status: "error" }, status: :payment_required }
+      end
     end
   end
 end