From ebf9383d34902dd51d3a0ba85ee1bd43ec4fbaa7 Mon Sep 17 00:00:00 2001
From: Graham Ollis <plicease@cpan.org>
Date: Wed, 23 Sep 2026 21:42:08 -0600
Subject: [PATCH 1/3] Silence uninitialized warnings for fields without a name
 (RT#106557)

A Submit or Button element with a value but no name triggered
"Use of uninitialized value $root in hash element" on every submitted
form, because Button sets force_default(1) and Field::process_input
passed the undefined nested_name to set_nested_hash_value.

The string renderers for Select, Textarea, Checkboxgroup (and so
Radiogroup) and ContentButton also emitted name="" with a sprintf
warning when the field had no name, and Date built sub-field names
from the undefined parent name. They now omit the name attribute,
matching the existing behaviour of the Input role.

The name() setter also accepts undef without a pattern-match warning.

Adds t/elements/unnamed_fields.t which traps warnings while processing
and rendering a form containing each affected element type.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 Changes                                  |  7 ++
 lib/HTML/FormFu/Element.pm               |  2 +-
 lib/HTML/FormFu/Element/Checkboxgroup.pm | 13 +++-
 lib/HTML/FormFu/Element/ContentButton.pm | 11 ++-
 lib/HTML/FormFu/Element/Date.pm          | 14 ++--
 lib/HTML/FormFu/Element/Select.pm        | 10 ++-
 lib/HTML/FormFu/Element/Textarea.pm      | 11 ++-
 lib/HTML/FormFu/Role/Element/Field.pm    |  3 +
 t/elements/unnamed_fields.t              | 94 ++++++++++++++++++++++++
 9 files changed, 144 insertions(+), 21 deletions(-)
 create mode 100644 t/elements/unnamed_fields.t

diff --git a/Changes b/Changes
index a4a9db8d..0a1b59c4 100644
--- a/Changes
+++ b/Changes
@@ -1,5 +1,12 @@
 {{$NEXT}}
 
+    - Fields without a name no longer emit "Use of uninitialized value"
+      warnings when a form is processed or rendered: an unnamed Submit or
+      Button with a value triggered one via force_default, and the Select,
+      Textarea, Checkboxgroup, Radiogroup, ContentButton and Date string
+      renderers emitted name="" with a warning. The name attribute is now
+      omitted, matching the other Input elements. RT#106557
+
     - Migrate from List::MoreUtils to List::SomeUtils
 
     - Fix CVE-2026-19873: bound the Repeatable element's counter_name
diff --git a/lib/HTML/FormFu/Element.pm b/lib/HTML/FormFu/Element.pm
index 660b1458..39c6930f 100644
--- a/lib/HTML/FormFu/Element.pm
+++ b/lib/HTML/FormFu/Element.pm
@@ -65,7 +65,7 @@ sub name {
 
     if ( @_ > 1 ) {
 
-        if ( $name =~ /[\.\[\]]/ ) {
+        if ( defined $name && $name =~ /[\.\[\]]/ ) {
             croak <<'ERROR_MESSAGE';
 element names may not contain periods or square brackets
 see documentation on nested_names() for details
diff --git a/lib/HTML/FormFu/Element/Checkboxgroup.pm b/lib/HTML/FormFu/Element/Checkboxgroup.pm
index 5a547cd1..0c7e5825 100644
--- a/lib/HTML/FormFu/Element/Checkboxgroup.pm
+++ b/lib/HTML/FormFu/Element/Checkboxgroup.pm
@@ -150,6 +150,11 @@ sub _string_field {
 
     # radiogroup_tag template
 
+    my $name_attr
+        = defined $render->{nested_name}
+        ? sprintf( qq{ name="%s"}, $render->{nested_name} )
+        : q{};
+
     my $html .= sprintf "<span%s>\n", process_attrs( $render->{attributes} );
 
     for my $option ( @{ $render->{options} } ) {
@@ -174,8 +179,8 @@ sub _string_field {
                     ;
 
                 my $input = sprintf
-                    qq{<input name="%s" type="%s" value="%s"%s />\n},
-                    $render->{nested_name},
+                    qq{<input%s type="%s" value="%s"%s />\n},
+                    $name_attr,
                     $render->{input_type},
                     $item->{value},
                     process_attrs( $item->{attributes} ),
@@ -205,8 +210,8 @@ sub _string_field {
                 ;
 
             my $input = sprintf
-                qq{<input name="%s" type="%s" value="%s"%s />\n},
-                $render->{nested_name},
+                qq{<input%s type="%s" value="%s"%s />\n},
+                $name_attr,
                 $render->{input_type},
                 $option->{value},
                 process_attrs( $option->{attributes} ),
diff --git a/lib/HTML/FormFu/Element/ContentButton.pm b/lib/HTML/FormFu/Element/ContentButton.pm
index 5f5c032f..64ef1b4d 100644
--- a/lib/HTML/FormFu/Element/ContentButton.pm
+++ b/lib/HTML/FormFu/Element/ContentButton.pm
@@ -46,10 +46,13 @@ sub _string_field {
 
     # content_button template
 
-    my $html .= sprintf qq{<button name="%s" type="%s"},
-        $render->{nested_name},
-        $render->{field_type},
-        ;
+    my $html = "<button";
+
+    if ( defined $render->{nested_name} ) {
+        $html .= sprintf qq{ name="%s"}, $render->{nested_name};
+    }
+
+    $html .= sprintf qq{ type="%s"}, $render->{field_type};
 
     if ( defined $render->{value} ) {
         $html .= sprintf qq{ value="%s"}, $render->{value};
diff --git a/lib/HTML/FormFu/Element/Date.pm b/lib/HTML/FormFu/Element/Date.pm
index 8a67b6f4..0e598117 100644
--- a/lib/HTML/FormFu/Element/Date.pm
+++ b/lib/HTML/FormFu/Element/Date.pm
@@ -381,12 +381,12 @@ sub _build_number_list {
 sub _build_name {
     my ( $self, $type ) = @_;
 
-    my $name
-        = defined $self->$type->{name}
-        ? $self->$type->{name}
-        : sprintf "%s_%s", $self->name, $type;
+    return $self->$type->{name} if defined $self->$type->{name};
 
-    return $name;
+    # a Date element without a name has unnamed sub-fields
+    return if !defined $self->name;
+
+    return sprintf "%s_%s", $self->name, $type;
 }
 
 sub _add_inflator {
@@ -437,6 +437,10 @@ sub process {
 sub process_input {
     my ( $self, $input ) = @_;
 
+    # a Date element without a name has no input to combine
+    return $self->SUPER::process_input($input)
+        if !defined $self->nested_name;
+
     my %value;
 
     my @order = @{ $self->field_order };
diff --git a/lib/HTML/FormFu/Element/Select.pm b/lib/HTML/FormFu/Element/Select.pm
index 86d581fa..398df698 100644
--- a/lib/HTML/FormFu/Element/Select.pm
+++ b/lib/HTML/FormFu/Element/Select.pm
@@ -62,9 +62,13 @@ sub _string_field {
 
     # select_tag template
 
-    my $html .= sprintf qq{<select name="%s"%s>\n},
-        $render->{nested_name},
-        process_attrs( $render->{attributes} );
+    my $html = "<select";
+
+    if ( defined $render->{nested_name} ) {
+        $html .= sprintf qq{ name="%s"}, $render->{nested_name};
+    }
+
+    $html .= sprintf "%s>\n", process_attrs( $render->{attributes} );
 
     for my $option ( @{ $render->{options} } ) {
         if ( exists $option->{group} ) {
diff --git a/lib/HTML/FormFu/Element/Textarea.pm b/lib/HTML/FormFu/Element/Textarea.pm
index 24420885..49093c59 100644
--- a/lib/HTML/FormFu/Element/Textarea.pm
+++ b/lib/HTML/FormFu/Element/Textarea.pm
@@ -36,10 +36,13 @@ sub _string_field {
 
     # textarea_tag template
 
-    my $html = sprintf qq{<textarea name="%s"%s>},
-        $render->{nested_name},
-        process_attrs( $render->{attributes} ),
-        ;
+    my $html = "<textarea";
+
+    if ( defined $render->{nested_name} ) {
+        $html .= sprintf qq{ name="%s"}, $render->{nested_name};
+    }
+
+    $html .= sprintf "%s>", process_attrs( $render->{attributes} );
 
     if ( defined $render->{value} ) {
         $html .= $render->{value};
diff --git a/lib/HTML/FormFu/Role/Element/Field.pm b/lib/HTML/FormFu/Role/Element/Field.pm
index cb76f2a0..2dfff21d 100644
--- a/lib/HTML/FormFu/Role/Element/Field.pm
+++ b/lib/HTML/FormFu/Role/Element/Field.pm
@@ -386,6 +386,9 @@ sub process_input {
     my $original  = $self->value;
     my $name      = $self->nested_name;
 
+    # a field without a name has no input to process
+    return if !defined $name;
+
     # set input to default value (defined before calling FormFu->process)
     if ( $submitted && $self->force_default && defined $default ) {
         $self->set_nested_hash_value( $input, $name, $default );
diff --git a/t/elements/unnamed_fields.t b/t/elements/unnamed_fields.t
new file mode 100644
index 00000000..2004b974
--- /dev/null
+++ b/t/elements/unnamed_fields.t
@@ -0,0 +1,94 @@
+use strict;
+use warnings;
+
+use Test::More tests => 12;
+
+use HTML::FormFu;
+
+# RT#106557 - fields without a name must not emit
+# "Use of uninitialized value $root in hash element" (or any other
+# 'uninitialized' warning) during process() or render()
+
+my @warnings;
+local $SIG{__WARN__} = sub { push @warnings, @_ };
+
+my $form = HTML::FormFu->new(
+    { tt_args => { INCLUDE_PATH => 'share/templates/tt/xhtml' } } );
+
+$form->populate(
+    {   elements => [
+            { type => 'Text', name => 'foo' },
+
+            # a Button's force_default(1) used to hit the nested-hash
+            # code with an undefined name
+            { type => 'Submit',        value   => 'Go' },
+            { type => 'Button',        value   => 'Push' },
+            { type => 'ContentButton', content => 'Click' },
+            { type => 'Text' },
+            { type => 'Textarea' },
+            { type => 'Select',        options => [ [ 1, 'one' ] ] },
+            { type => 'Radiogroup',    options => [ [ 1, 'one' ] ] },
+            { type => 'Checkboxgroup', options => [ [ 1, 'one' ] ] },
+            { type => 'Date' },
+        ],
+    } );
+
+$form->process( { foo => 'bar' } );
+
+ok( $form->submitted_and_valid, 'submitted_and_valid' );
+
+is( $form->param_value('foo'), 'bar', 'named field value' );
+
+is_deeply( [ keys %{ $form->params } ], ['foo'], 'only named field in params' );
+
+my $string_html = $form->render;
+
+like(
+    $string_html,
+    qr{<input type="submit" value="Go" />},
+    'unnamed submit renders without name attribute'
+);
+
+like( $string_html, qr{<select>},
+    'unnamed select renders without name attribute' );
+
+like(
+    $string_html,
+    qr{<textarea cols="40" rows="20">},
+    'unnamed textarea renders without name attribute'
+);
+
+like(
+    $string_html,
+    qr{<button type="button">Click</button>},
+    'unnamed content button renders without name attribute'
+);
+
+like(
+    $string_html,
+    qr{<input type="radio" value="1" />},
+    'unnamed radiogroup renders without name attribute'
+);
+
+like(
+    $string_html,
+    qr{<input type="checkbox" value="1" />},
+    'unnamed checkboxgroup renders without name attribute'
+);
+
+$form->render_method('tt');
+
+$form->render;
+
+# setting the name to undef should also be silent
+
+$form->get_field('foo')->name(undef);
+
+is( $form->get_field( { type => 'Text' } )->name, undef, 'name(undef)' );
+
+$form->process( { foo => 'bar' } );
+
+is_deeply( $form->params, {}, 'no params once every field is unnamed' );
+
+is_deeply( \@warnings, [], 'no warnings' )
+    or diag( join '', @warnings );

From ae101e03571ae1be27ce6a1a4bdcaf971831673f Mon Sep 17 00:00:00 2001
From: Graham Ollis <plicease@cpan.org>
Date: Wed, 23 Sep 2026 21:43:18 -0600
Subject: [PATCH 2/3] update copyright

---
 Changes    |  2 ++
 README.pod | 23 ++++++++++++++++++++++-
 dist.ini   |  2 +-
 3 files changed, 25 insertions(+), 2 deletions(-)

diff --git a/Changes b/Changes
index 0a1b59c4..bdf94377 100644
--- a/Changes
+++ b/Changes
@@ -7,6 +7,8 @@
       renderers emitted name="" with a warning. The name attribute is now
       omitted, matching the other Input elements. RT#106557
 
+    - New github org: uperl
+
     - Migrate from List::MoreUtils to List::SomeUtils
 
     - Fix CVE-2026-19873: bound the Repeatable element's counter_name
diff --git a/README.pod b/README.pod
index 5d828cf2..383800de 100644
--- a/README.pod
+++ b/README.pod
@@ -2,6 +2,14 @@
 
 =encoding UTF-8
 
+=head1 NAME
+
+HTML::FormFu - HTML Form Creation, Rendering and Validation Framework
+
+=head1 VERSION
+
+version 2.08
+
 =head1 SYNOPSIS
 
 Note: These examples make use of L<HTML::FormFu::Model::DBIC>. As of
@@ -268,6 +276,19 @@ used as the return value for L</submitted>.
 If L</indicator> is not set, L</submitted> will return true if a value for
 any known fieldname was submitted.
 
+=head2 repeatable_max_counter
+
+Arguments: $number
+
+Default Value: C<100>
+
+The default L<max_counter|HTML::FormFu::Element::Repeatable/max_counter>
+for all L<Repeatable|HTML::FormFu::Element::Repeatable> elements in this
+form. Individual Repeatable elements can override this by setting their own
+L<max_counter|HTML::FormFu::Element::Repeatable/max_counter>.
+
+Set to C<0> to disable clamping form-wide.
+
 =head2 auto_fieldset
 
 Arguments: 1
@@ -1999,7 +2020,7 @@ Carl Franks <cpan@fireartist.com>
 
 =head1 COPYRIGHT AND LICENSE
 
-This software is copyright (c) 2018 by Carl Franks.
+This software is copyright (c) 2026, 2018, 2016, 2015, 2012, 2011 by Carl Franks.
 
 This is free software; you can redistribute it and/or modify it under
 the same terms as the Perl 5 programming language system itself.
diff --git a/dist.ini b/dist.ini
index dc89b2ee..90443583 100644
--- a/dist.ini
+++ b/dist.ini
@@ -2,7 +2,7 @@ name    = HTML-FormFu
 author  = Carl Franks <cpan@fireartist.com>
 license = Perl_5
 copyright_holder = Carl Franks
-copyright_year   = 2021
+copyright_year   = 2026
 main_module = lib/HTML/FormFu.pm
 
 [Prereqs]

From 37de80de9a7af4b9d053c1f4c958ff8270d79355 Mon Sep 17 00:00:00 2001
From: Graham Ollis <plicease@cpan.org>
Date: Wed, 23 Sep 2026 21:52:01 -0600
Subject: [PATCH 3/3] Constraint when() with not(1) now applies when the field
 is missing (RT#45409)

A constraint such as

    when: { field: some_checkbox, values: [x], not: 1 }

was skipped whenever the checkbox was unchecked, because an unchecked
checkbox submits nothing and _process_when returned false for a
missing field before consulting 'not'. Users had to set
default_empty_value on the checkbox to make 'not' work.

A missing field's undefined value is now treated as not matching, in
both the value-list and truthiness checks. With 'not' set that fulfils
the condition and the constraint is applied. Without 'not' a missing
'field' still skips the constraint as before.

Behaviour change: with 'fields', a missing field was previously
silently ignored and the remaining fields decided the outcome. It now
counts as not passing, matching the documented "all named fields'
values pass" semantics.

Documents the missing-field rule under field, fields and not, and adds
t/constraints/constraint_when_not_missing_field.t covering field,
fields and any_field, with and without not.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 Changes                                       |  10 ++
 lib/HTML/FormFu/Constraint.pm                 |  37 +++---
 .../constraint_when_not_missing_field.t       | 117 ++++++++++++++++++
 .../constraint_when_not_missing_field.yml     |  65 ++++++++++
 4 files changed, 210 insertions(+), 19 deletions(-)
 create mode 100644 t/constraints/constraint_when_not_missing_field.t
 create mode 100644 t/constraints/constraint_when_not_missing_field.yml

diff --git a/Changes b/Changes
index bdf94377..ea5b92c2 100644
--- a/Changes
+++ b/Changes
@@ -1,5 +1,15 @@
 {{$NEXT}}
 
+    - Constraint when() with not(1) now applies the constraint when the
+      named field is missing from the submission, such as an unchecked
+      Checkbox. Previously a missing field caused the constraint to be
+      skipped regardless of not(), so default_empty_value was needed on
+      the Checkbox. RT#45409
+
+    - Behaviour change: Constraint when() with fields() now requires
+      every named field to be present and match. Previously a missing
+      field was silently ignored.
+
     - Fields without a name no longer emit "Use of uninitialized value"
       warnings when a form is processed or rendered: an unnamed Submit or
       Button with a value triggered one via force_default, and the Select,
diff --git a/lib/HTML/FormFu/Constraint.pm b/lib/HTML/FormFu/Constraint.pm
index 1924b754..60518851 100644
--- a/lib/HTML/FormFu/Constraint.pm
+++ b/lib/HTML/FormFu/Constraint.pm
@@ -259,30 +259,22 @@ sub _process_when {
         croak "'fields' is set to an empty list" if !@$when_fields;
 
         for my $name (@$when_fields) {
-            my $value = $self->get_nested_hash_value( $params, $name );
-
-            push @when_fields_value, $value
-                if defined $value;
+            push @when_fields_value,
+                $self->get_nested_hash_value( $params, $name );
         }
     }
     else {
-
-        # nothing to constrain if field doesn't exist
-        my $value = $self->get_nested_hash_value( $params, $when_field );
-
-        push @when_fields_value, $value
-            if defined $value;
+        push @when_fields_value,
+            $self->get_nested_hash_value( $params, $when_field );
     }
 
+    # a field missing from the submission (e.g. an unchecked Checkbox) has
+    # an undefined value, which is treated as not matching - so with 'not'
+    # set, the condition is fulfilled and the constraint is applied. RT#45409
+
     DEBUG_CONSTRAINTS_WHEN
         && debug( 'WHEN_FIELDS_VALUES' => \@when_fields_value );
 
-    if ( !@when_fields_value ) {
-        DEBUG_CONSTRAINTS_WHEN
-            && debug("No 'when' fields values exist - returning false");
-        return 0;
-    }
-
     my @values;
 
     if ( defined( my $value = $when->{value} ) ) {
@@ -297,12 +289,13 @@ sub _process_when {
 
     if (@values) {
         for my $value (@when_fields_value) {
-            push @ok, any { $value eq $_ } @values;
+            push @ok,
+                ( defined $value && any { $value eq $_ } @values ) ? 1 : 0;
         }
     }
     else {
         for my $value (@when_fields_value) {
-            push @ok, $value ? 1 : 0;
+            push @ok, ( defined $value && $value ) ? 1 : 0;
         }
     }
 
@@ -492,10 +485,14 @@ Nested-name of form field that shall be checked against - if C<< when->{value} >
 is set, the C<when> condition passes if the named field's value matches that,
 otherwise the C<when> condition passes if the named field's value is true.
 
+If the named field is missing from the submission altogether (as an unchecked
+Checkbox is), its value is treated as not matching.
+
 =item fields
 
 Array-ref of nested-names that shall be checked. The C<when> condition passes
 if all named-fields' values pass, using the same rules as C<field> above.
+A field missing from the submission does not pass.
 
 =item any_field
 
@@ -512,7 +509,9 @@ Array of multiple values, one must match to fulfill the condition
 
 =item not
 
-Inverts the when condition - value(s) must not match
+Inverts the when condition - value(s) must not match. A field missing from the
+submission counts as not matching, so a constraint with C<not> set is applied
+when, for example, the named Checkbox is unchecked.
 
 =item callback
 
diff --git a/t/constraints/constraint_when_not_missing_field.t b/t/constraints/constraint_when_not_missing_field.t
new file mode 100644
index 00000000..5067cc79
--- /dev/null
+++ b/t/constraints/constraint_when_not_missing_field.t
@@ -0,0 +1,117 @@
+use strict;
+use warnings;
+
+use Test::More tests => 15;
+
+use HTML::FormFu;
+
+my $form = HTML::FormFu->new;
+
+$form->load_config_file('t/constraints/constraint_when_not_missing_field.yml');
+
+# field + not
+
+# invalid - checkbox unchecked (missing) - fieldname required
+{
+    $form->process( { fieldname => '' } );
+
+    ok( !$form->submitted_and_valid, 'field+not: unchecked, empty' );
+    ok( !$form->valid('fieldname'),  'fieldname not valid' );
+}
+
+# valid - checkbox unchecked (missing) - fieldname supplied
+{
+    $form->process( { fieldname => 'x' } );
+
+    ok( $form->valid('fieldname'), 'field+not: unchecked, supplied' );
+}
+
+# valid - checkbox checked - fieldname optional
+{
+    $form->process( { fieldname => '', some_checkbox => 'it_is_checked' } );
+
+    ok( $form->valid('fieldname'), 'field+not: checked, empty' );
+}
+
+# fields + not
+
+# invalid - both missing - baz required
+{
+    $form->process( { baz => '' } );
+
+    ok( !$form->valid('baz'), 'fields+not: both missing' );
+}
+
+# valid - one checked - condition not fulfilled
+{
+    $form->process( { baz => '', c1 => 1 } );
+
+    ok( $form->valid('baz'), 'fields+not: one checked' );
+}
+
+# valid - both checked
+{
+    $form->process( { baz => '', c1 => 1, c2 => 1 } );
+
+    ok( $form->valid('baz'), 'fields+not: both checked' );
+}
+
+# any_field + not
+
+# invalid - both missing - quux required
+{
+    $form->process( { quux => '' } );
+
+    ok( !$form->valid('quux'), 'any_field+not: both missing' );
+}
+
+# invalid - one missing - quux required
+{
+    $form->process( { quux => '', d1 => 1 } );
+
+    ok( !$form->valid('quux'), 'any_field+not: one missing' );
+}
+
+# valid - both checked
+{
+    $form->process( { quux => '', d1 => 1, d2 => 1 } );
+
+    ok( $form->valid('quux'), 'any_field+not: both checked' );
+}
+
+# fields without not
+
+# valid - both missing - qux optional
+{
+    $form->process( { qux => '' } );
+
+    ok( $form->valid('qux'), 'fields: both missing' );
+}
+
+# valid - one missing - qux optional
+{
+    $form->process( { qux => '', e1 => 1 } );
+
+    ok( $form->valid('qux'), 'fields: one missing' );
+}
+
+# invalid - both checked - qux required
+{
+    $form->process( { qux => '', e1 => 1, e2 => 1 } );
+
+    ok( !$form->valid('qux'), 'fields: both checked' );
+}
+
+# valid - both checked and qux supplied
+{
+    $form->process( { qux => 'x', e1 => 1, e2 => 1 } );
+
+    ok( $form->valid('qux'), 'fields: both checked, supplied' );
+}
+
+# an unrelated field with no when is unaffected
+{
+    $form->process( { fieldname => 'x', baz => 'x', quux => 'x' } );
+
+    ok( $form->submitted_and_valid, 'everything supplied' );
+}
diff --git a/t/constraints/constraint_when_not_missing_field.yml b/t/constraints/constraint_when_not_missing_field.yml
new file mode 100644
index 00000000..29281e7c
--- /dev/null
+++ b/t/constraints/constraint_when_not_missing_field.yml
@@ -0,0 +1,65 @@
+---
+elements:
+    # RT#45409 - 'not' must apply when the checkbox is unchecked,
+    # i.e. missing from the submission, without needing
+    # default_empty_value on the checkbox
+    - name: fieldname
+      constraints:
+        - type: Required
+          when:
+            field: some_checkbox
+            values: ['it_is_checked']
+            not: 1
+
+    - type: Checkbox
+      name: some_checkbox
+      value: it_is_checked
+
+    # 'fields' + 'not' - all named fields must not match
+    - name: baz
+      constraints:
+        - type: Required
+          when:
+            fields: [c1, c2]
+            value: 1
+            not: 1
+
+    - type: Checkbox
+      name: c1
+      value: 1
+
+    - type: Checkbox
+      name: c2
+      value: 1
+
+    # 'any_field' + 'not' - any named field must not match
+    - name: quux
+      constraints:
+        - type: Required
+          when:
+            any_field: [d1, d2]
+            value: 1
+            not: 1
+
+    - type: Checkbox
+      name: d1
+      value: 1
+
+    - type: Checkbox
+      name: d2
+      value: 1
+
+    # 'fields' without 'not' - a missing field does not pass
+    - name: qux
+      constraints:
+        - type: Required
+          when:
+            fields: [e1, e2]
+
+    - type: Checkbox
+      name: e1
+      value: 1
+
+    - type: Checkbox
+      name: e2
+      value: 1