diff --git a/apps/ember-test-app/app/components/f/form.gts b/apps/ember-test-app/app/components/f/form.gts
index 57808b634..900f1cd64 100644
--- a/apps/ember-test-app/app/components/f/form.gts
+++ b/apps/ember-test-app/app/components/f/form.gts
@@ -26,11 +26,33 @@ const Validators = {
         console.log('Validating: ' + value);
         return value !== 'foo';
       },
+      isWarning: true,
+    }),
+  ],
+  radio: [validator('exclusion', { in: ['A', 'B'], isWarning: true })],
+  phone: [
+    validator('length', {
+      min: 10,
+      message: 'Phone number must contain a 3-digit area code',
+      disabled() {
+        return !this.requirePhoneLength;
+      },
+    }),
+    validator('length', {
+      max: 10,
+      isWarning: true,
+      message: 'Phone number cannot contain a country code',
+      disabled() {
+        return !this.requirePhoneLength;
+      },
     }),
   ],
 };
 
 class Model {
+  @tracked
+  requirePhoneLength = true;
+
   @tracked
   textField = '';
 
@@ -40,6 +62,9 @@ class Model {
   @tracked
   select = '';
 
+  @tracked
+  phone = '';
+
   @tracked
   radio = '';
 
@@ -86,6 +111,11 @@ export default class extends Component {
     this.required = !this.required;
   }
 
+  @action
+  toggleRequirePhoneLength() {
+    this.model.requirePhoneLength = !this.model.requirePhoneLength;
+  }
+
   @action
   onSubmit() {
     alert('Form submitted');
@@ -138,12 +168,29 @@ export default class extends Component {
             </Field.RadioGroup>
           </Form.Field>
         </div>
+        <div class="mb-3">
+          <Form.Field
+            @label="Phone Number"
+            @required={{this.required}}
+            as |Field|
+          >
+            <Field.Phone @binding={{bind this.model "phone"}} />
+          </Form.Field>
+        </div>
         <Form.SubmitButton class="btn-primary mt-3" />
         <Button
           class="btn{{unless this.required '-outline'}}-secondary mt-3"
           @text="Toggle Required"
           @onClick={{this.toggleRequired}}
         />
+        <Button
+          class="btn{{unless
+              this.model.requirePhoneLength
+              '-outline'
+            }}-secondary mt-3"
+          @text="Toggle Phone Length"
+          @onClick={{this.toggleRequirePhoneLength}}
+        />
       </Form>
       <hr />
       <div class="grid">
diff --git a/apps/ember-test-app/config/environment.js b/apps/ember-test-app/config/environment.js
index 85d4b7e0f..9c44ae667 100644
--- a/apps/ember-test-app/config/environment.js
+++ b/apps/ember-test-app/config/environment.js
@@ -7,7 +7,7 @@ module.exports = function (environment) {
     rootURL: '/',
     locationType: 'history',
     EmberENV: {
-      EXTEND_PROTOTYPES: true,
+      EXTEND_PROTOTYPES: false,
       FEATURES: {
         // Here you can enable experimental features on an ember canary build
         // e.g. EMBER_NATIVE_DECORATOR_SUPPORT: true
diff --git a/apps/ember-test-app/tests/integration/components/form/index-test.gts b/apps/ember-test-app/tests/integration/components/form/index-test.gts
index 877011a4a..010b84ff6 100644
--- a/apps/ember-test-app/tests/integration/components/form/index-test.gts
+++ b/apps/ember-test-app/tests/integration/components/form/index-test.gts
@@ -1,8 +1,10 @@
 import { setOwner } from '@ember/application';
+import { array } from '@ember/helper';
 import { click, fillIn, render } from '@ember/test-helpers';
 import { tracked } from '@glimmer/tracking';
 import Form from '@nrg-ui/ember/components/form';
 import bind from '@nrg-ui/ember/helpers/bind';
+import { validator } from '@nrg-ui/ember/validation';
 import { setupIntl } from 'ember-intl/test-support';
 import { setupRenderingTest } from 'ember-qunit';
 import { module, test } from 'qunit';
@@ -15,6 +17,13 @@ class Model {
   textArea: string = '';
 }
 
+const Validators = {
+  selectByAnotherProperty: validator('presence', {
+    presence: false,
+    isWarning: true,
+  }),
+};
+
 module('Integration | Component | form', function (hooks) {
   setupRenderingTest(hooks);
   setupIntl(hooks, 'en-us');
@@ -101,7 +110,7 @@ module('Integration | Component | form', function (hooks) {
   });
 
   test('validations work', async function (assert) {
-    assert.expect(12);
+    assert.expect(20);
 
     const model = this.model;
 
@@ -111,7 +120,7 @@ module('Integration | Component | form', function (hooks) {
     };
 
     await render(<template>
-      <Form @onSubmit={{actionHandler}} as |Form|>
+      <Form @validators={{Validators}} @onSubmit={{actionHandler}} as |Form|>
         <Form.Field @label="Text Field" @required={{true}} as |Field|>
           <Field.TextField @binding={{bind model "textField"}} />
         </Form.Field>
@@ -125,11 +134,43 @@ module('Integration | Component | form', function (hooks) {
             Here's some extra context for this field
           </Field.Text>
         </Form.Field>
+        <Form.Field
+          @label="Select"
+          @validatorKey="selectByAnotherProperty"
+          as |Field|
+        >
+          <Field.Select
+            @binding={{bind model "select"}}
+            @options={{array "A" "B" "C"}}
+          />
+        </Form.Field>
         <Form.SubmitButton />
       </Form>
     </template>);
 
-    await click('button');
+    // Select
+    const select = this.element.querySelector('label + button.dropdown');
+
+    assert
+      .dom(select)
+      .exists()
+      .hasAttribute('role', 'combobox')
+      .hasClass('form-control');
+
+    await click(select);
+    await click('button > .dropdown-menu > li:first-child');
+
+    const ariaId = select.getAttribute('aria-describedby');
+
+    assert.dom('button.dropdown').doesNotHaveClass('is-invalid');
+    assert
+      .dom('button.dropdown + div')
+      .exists()
+      .hasAttribute('id', ariaId)
+      .hasClass('warning-feedback')
+      .containsText('This field must be blank');
+
+    await click('button[type="submit"]');
 
     assert.false(didSubmit, 'Form should not submit when validations fail');
 
@@ -159,7 +200,7 @@ module('Integration | Component | form', function (hooks) {
       assert.ok(true, 'Form should submit');
     };
 
-    await click('button');
+    await click('button[type="submit"]');
 
     assert.true(didSubmit, 'Form should submit when validations pass');
   });
diff --git a/apps/ember-test-app/tests/unit/validators/base-test.ts b/apps/ember-test-app/tests/unit/validators/base-test.ts
new file mode 100644
index 000000000..28d9e404a
--- /dev/null
+++ b/apps/ember-test-app/tests/unit/validators/base-test.ts
@@ -0,0 +1,569 @@
+import { setOwner } from '@ember/application';
+import { tracked } from '@glimmer/tracking';
+import { bind } from '@nrg-ui/ember/helpers/bind';
+import { BaseValidator } from '@nrg-ui/ember/validation';
+import { addTranslations, setupIntl } from 'ember-intl/test-support';
+import { setupTest } from 'ember-test-app/tests/helpers';
+import { module, test } from 'qunit';
+
+import type Owner from '@ember/owner';
+import type { TestContext as TC } from '@ember/test-helpers';
+import type { Binding } from '@nrg-ui/ember';
+import type { BaseOptions, ValidateFnResponse } from '@nrg-ui/ember/validation';
+
+class Model {
+  @tracked
+  disabled: boolean = false;
+}
+
+type DummyOptions<T extends ValidateFnResponse> = BaseOptions & {
+  response?: T;
+};
+
+class DummyValidator<T extends ValidateFnResponse> extends BaseValidator<
+  T,
+  Model,
+  Model,
+  DummyOptions<T>
+> {
+  validate(
+    this: BaseValidator<T, Model, Model, DummyOptions<T>>,
+    value: T,
+    options: DummyOptions<T>,
+  ) {
+    return options.response ?? true;
+  }
+}
+
+declare type TestContext = {
+  binding: Binding<Model>;
+  model: Model;
+} & TC;
+
+module('Unit | Validator | base', function (hooks) {
+  setupTest(hooks);
+  setupIntl(hooks, 'en-us');
+
+  hooks.beforeEach(function (this: TestContext) {
+    this.model = new Model();
+    this.binding = bind(this.model, 'field');
+
+    setOwner(this.model, this.owner);
+  });
+
+  test('`validate` function is required', function (this: TestContext, assert) {
+    assert.expect(1);
+
+    assert.throws(() => {
+      // @ts-expect-error TS disallows instantiating an abstract class
+      const validator = new BaseValidator(this.binding, {}, this.model);
+      const result = validator.result;
+
+      assert.notOk(
+        true,
+        'Expected an error, but got a result instead: ' + result,
+      );
+    }, new Error('Assertion Failed: BaseValidator requires the `validate` function to be implemented by subclasses'));
+  });
+
+  test('`binding` option is required', function (this: TestContext, assert) {
+    assert.expect(1);
+
+    assert.throws(() => {
+      // @ts-expect-error Testing that the `binding` option is required
+      const validator = new DummyValidator(null, {}, this.model);
+      const result = validator.result;
+
+      assert.notOk(
+        true,
+        'Expected an error, but got a result instead: ' + result,
+      );
+    }, new Error('Assertion Failed: You must provide a binding argument to DummyValidator'));
+  });
+
+  test('owner is required', function (this: TestContext, assert) {
+    assert.expect(3);
+
+    assert.throws(() => {
+      setOwner(this.model, undefined as unknown as Owner);
+      const validator = new DummyValidator(this.binding, {}, this.model);
+      const result = validator.result;
+
+      assert.notOk(
+        true,
+        'Expected an error, but got a result instead: ' + result,
+      );
+    }, new Error('Assertion Failed: The `context` or `model` must be have an owner. Usually this means the `context` or `model` is an EmberObject or GlimmerComponent, but this can be manually set up with `setOwner`'));
+
+    try {
+      setOwner(this.model, this.owner);
+      const validator = new DummyValidator(this.binding, {}, this.model);
+      const result = validator.result;
+
+      assert.true(result.isValid);
+    } catch (e) {
+      assert.notOk(true, 'Expected no error, but got an error instead: ' + e);
+    }
+
+    try {
+      const context = new Model();
+      setOwner(context, this.owner);
+      setOwner(this.model, null as unknown as Owner);
+      const validator = new DummyValidator(this.binding, {}, context);
+      const result = validator.result;
+
+      assert.true(result.isValid);
+    } catch (e) {
+      assert.notOk(true, 'Expected no error, but got an error instead: ' + e);
+    }
+  });
+
+  test('response can be a boolean', function (this: TestContext, assert) {
+    let validator: DummyValidator<boolean> = new DummyValidator(
+      this.binding,
+      {
+        response: true,
+      },
+      this.model,
+    );
+
+    let result = validator.result;
+
+    assert.deepEqual(result, {
+      isValid: true,
+      isWarning: false,
+      message: undefined,
+    });
+
+    validator = new DummyValidator(
+      this.binding,
+      {
+        response: false,
+      },
+      this.model,
+    );
+
+    result = validator.result;
+
+    assert.deepEqual(result, {
+      isValid: false,
+      isWarning: false,
+      message: undefined,
+    });
+
+    validator = new DummyValidator(
+      this.binding,
+      {
+        response: false,
+        isWarning: true,
+      },
+      this.model,
+    );
+
+    result = validator.result;
+
+    assert.deepEqual(result, {
+      isValid: false,
+      isWarning: true,
+      message: undefined,
+    });
+  });
+
+  test('response can be a string', function (this: TestContext, assert) {
+    const errorMessage = 'This field is really invalid';
+    const validator = new DummyValidator(
+      this.binding,
+      {
+        response: errorMessage,
+      },
+      this.model,
+    );
+
+    const result = validator.result;
+
+    assert.deepEqual(result, {
+      isValid: false,
+      isWarning: false,
+      message: errorMessage,
+    });
+  });
+
+  test('response can include a message', function (this: TestContext, assert) {
+    const errorMessage = 'This field is really invalid';
+    let validator = new DummyValidator(
+      this.binding,
+      {
+        response: false,
+        message: errorMessage,
+      },
+      this.model,
+    );
+
+    let result = validator.result;
+
+    assert.deepEqual(result, {
+      isValid: false,
+      isWarning: false,
+      message: errorMessage,
+    });
+
+    validator = new DummyValidator(
+      this.binding,
+      {
+        response: false,
+        message: errorMessage,
+        isWarning: true,
+      },
+      this.model,
+    );
+
+    result = validator.result;
+
+    assert.deepEqual(result, {
+      isValid: false,
+      isWarning: true,
+      message: errorMessage,
+    });
+  });
+
+  test('message from options supersedes response message', function (this: TestContext, assert) {
+    let validator = new DummyValidator(
+      this.binding,
+      {
+        response: {
+          isValid: false,
+          message: 'This is the response message',
+        },
+        message: 'This is the options message',
+      },
+      this.model,
+    );
+
+    let result = validator.result;
+
+    assert.deepEqual(result, {
+      isValid: false,
+      isWarning: false,
+      message: 'This is the options message',
+    });
+
+    validator = new DummyValidator(
+      this.binding,
+      {
+        response: {
+          isValid: false,
+          message: 'This is the response message',
+        },
+        message: 'This is the options message',
+        isWarning: true,
+      },
+      this.model,
+    );
+
+    result = validator.result;
+
+    assert.deepEqual(result, {
+      isValid: false,
+      isWarning: true,
+      message: 'This is the options message',
+    });
+  });
+
+  test('response can include a key', function (this: TestContext, assert) {
+    let validator = new DummyValidator(
+      this.binding,
+      {
+        response: false,
+        key: 'greeting',
+      },
+      this.model,
+    );
+
+    let result = validator.result;
+
+    assert.deepEqual(result, {
+      isValid: false,
+      isWarning: false,
+      message: 'Hello, world!',
+    });
+
+    validator = new DummyValidator(
+      this.binding,
+      {
+        response: false,
+        message: 'Hello, world!',
+        isWarning: true,
+      },
+      this.model,
+    );
+
+    result = validator.result;
+
+    assert.deepEqual(result, {
+      isValid: false,
+      isWarning: true,
+      message: 'Hello, world!',
+    });
+  });
+
+  test('key from options supersedes response key', async function (this: TestContext, assert) {
+    await addTranslations('en-us', {
+      'my.key': 'This is the correct message',
+    });
+
+    let validator = new DummyValidator(
+      this.binding,
+      {
+        response: {
+          isValid: false,
+          key: 'greeting',
+        },
+        key: 'my.key',
+      },
+      this.model,
+    );
+
+    let result = validator.result;
+
+    assert.deepEqual(result, {
+      isValid: false,
+      isWarning: false,
+      message: 'This is the correct message',
+    });
+
+    validator = new DummyValidator(
+      this.binding,
+      {
+        response: {
+          isValid: false,
+          key: 'greeting',
+        },
+        key: 'my.key',
+        isWarning: true,
+      },
+      this.model,
+    );
+
+    result = validator.result;
+
+    assert.deepEqual(result, {
+      isValid: false,
+      isWarning: true,
+      message: 'This is the correct message',
+    });
+  });
+
+  test('key from options supersedes response message', async function (this: TestContext, assert) {
+    await addTranslations('en-us', {
+      'my.key': 'This is the correct message',
+    });
+
+    let validator = new DummyValidator(
+      this.binding,
+      {
+        response: {
+          isValid: false,
+          message: 'This is the wrong message',
+        },
+        key: 'my.key',
+      },
+      this.model,
+    );
+
+    let result = validator.result;
+
+    assert.deepEqual(result, {
+      isValid: false,
+      isWarning: false,
+      message: 'This is the correct message',
+    });
+
+    validator = new DummyValidator(
+      this.binding,
+      {
+        response: {
+          isValid: false,
+          message: 'This is the wrong message',
+        },
+        key: 'my.key',
+        isWarning: true,
+      },
+      this.model,
+    );
+
+    result = validator.result;
+
+    assert.deepEqual(result, {
+      isValid: false,
+      isWarning: true,
+      message: 'This is the correct message',
+    });
+  });
+
+  test('message from options supersedes response key', async function (this: TestContext, assert) {
+    let validator = new DummyValidator(
+      this.binding,
+      {
+        response: {
+          isValid: false,
+          key: 'greeting',
+        },
+        message: 'This is the correct message',
+      },
+      this.model,
+    );
+
+    let result = validator.result;
+
+    assert.deepEqual(result, {
+      isValid: false,
+      isWarning: false,
+      message: 'This is the correct message',
+    });
+
+    validator = new DummyValidator(
+      this.binding,
+      {
+        response: {
+          isValid: false,
+          key: 'greeting',
+        },
+        message: 'This is the correct message',
+        isWarning: true,
+      },
+      this.model,
+    );
+
+    result = validator.result;
+
+    assert.deepEqual(result, {
+      isValid: false,
+      isWarning: true,
+      message: 'This is the correct message',
+    });
+  });
+
+  test('key from options supersedes options message', async function (this: TestContext, assert) {
+    await addTranslations('en-us', {
+      'my.key': 'This is the correct message',
+    });
+
+    let validator = new DummyValidator(
+      this.binding,
+      {
+        response: {
+          isValid: false,
+        },
+        message: 'This is the wrong message',
+        key: 'my.key',
+      },
+      this.model,
+    );
+
+    let result = validator.result;
+
+    assert.deepEqual(result, {
+      isValid: false,
+      isWarning: false,
+      message: 'This is the correct message',
+    });
+
+    validator = new DummyValidator(
+      this.binding,
+      {
+        response: {
+          isValid: false,
+        },
+        message: 'This is the wrong message',
+        key: 'my.key',
+        isWarning: true,
+      },
+      this.model,
+    );
+
+    result = validator.result;
+
+    assert.deepEqual(result, {
+      isValid: false,
+      isWarning: true,
+      message: 'This is the correct message',
+    });
+  });
+
+  test('key from response supersedes response message', async function (this: TestContext, assert) {
+    await addTranslations('en-us', {
+      'my.key': 'This is the correct message',
+    });
+
+    let validator = new DummyValidator(
+      this.binding,
+      {
+        response: {
+          isValid: false,
+          key: 'my.key',
+          message: 'This is the wrong message',
+        },
+      },
+      this.model,
+    );
+
+    let result = validator.result;
+
+    assert.deepEqual(result, {
+      isValid: false,
+      isWarning: false,
+      message: 'This is the correct message',
+    });
+
+    validator = new DummyValidator(
+      this.binding,
+      {
+        response: {
+          isValid: false,
+          key: 'my.key',
+          message: 'This is the wrong message',
+        },
+        isWarning: true,
+      },
+      this.model,
+    );
+
+    result = validator.result;
+
+    assert.deepEqual(result, {
+      isValid: false,
+      isWarning: true,
+      message: 'This is the correct message',
+    });
+  });
+
+  test('disabled option works', async function (this: TestContext, assert) {
+    const validator = new DummyValidator(
+      this.binding,
+      {
+        response: false,
+        message: 'This field is bad',
+        disabled() {
+          return this.disabled;
+        },
+      },
+      this.model,
+    );
+
+    let result = validator.result;
+
+    assert.deepEqual(result, {
+      isValid: false,
+      isWarning: false,
+      message: 'This field is bad',
+    });
+
+    this.model.disabled = true;
+
+    result = validator.result;
+
+    assert.deepEqual(result, {
+      isValid: true,
+    });
+  });
+});
diff --git a/apps/ember-test-app/tests/unit/validators/custom-test.ts b/apps/ember-test-app/tests/unit/validators/custom-test.ts
index 43c2a2ad5..56fad8752 100644
--- a/apps/ember-test-app/tests/unit/validators/custom-test.ts
+++ b/apps/ember-test-app/tests/unit/validators/custom-test.ts
@@ -15,6 +15,9 @@ import type { Binding } from '@nrg-ui/ember';
 class Model {
   @tracked
   field?: string | string[];
+
+  @tracked
+  disabled: boolean = false;
 }
 
 declare type TestContext = {
@@ -33,10 +36,11 @@ module('Unit | Validator | custom', function (hooks) {
     setOwner(this.model, this.owner);
   });
 
-  test('`on` option is required', function (this: TestContext, assert) {
+  test('`validate` option is required', function (this: TestContext, assert) {
     assert.expect(1);
 
     assert.throws(() => {
+      // @ts-expect-error Testing that the `validate` option is required
       const validator = new CustomValidator(this.binding, {}, this.model);
       const result = validator.result;
 
@@ -138,6 +142,39 @@ module('Unit | Validator | custom', function (hooks) {
     });
   });
 
+  test('disabled option works', async function (this: TestContext, assert) {
+    const validator = new CustomValidator(
+      this.binding,
+      {
+        validate() {
+          return false;
+        },
+        disabled() {
+          return this.disabled;
+        },
+      },
+      this.model,
+    );
+
+    this.model.field = ['foo', 'bar'];
+
+    let result = validator.result;
+
+    assert.deepEqual(result, {
+      isValid: false,
+      isWarning: false,
+      message: 'This field is invalid',
+    });
+
+    this.model.disabled = true;
+
+    result = validator.result;
+
+    assert.deepEqual(result, {
+      isValid: true,
+    });
+  });
+
   test('works with `validator` function', function (this: TestContext, assert) {
     const builder = buildValidator('custom', {
       validate: () => {
diff --git a/packages/design-system/src/_forms.scss b/packages/design-system/src/_forms.scss
index 541e85e2b..1bc5780aa 100644
--- a/packages/design-system/src/_forms.scss
+++ b/packages/design-system/src/_forms.scss
@@ -10,3 +10,78 @@
     overflow-y: auto;
   }
 }
+
+/* I'm open to changing the color (it's the "orange" color from
+ * Fomantic) but I think it's a good idea to have a color that's
+ * different from the default "warning" color from Bootstrap.
+ * The default Bootstrap warning color is hard to read, and the
+ * "emphasis" variant is gross (see `text-warning-emphasis`):
+ * <https://getbootstrap.com/docs/5.3/utilities/colors/#colors>
+ */
+$warning-custom: #f2711c;
+:root {
+  --bs-form-warning-rgb: 242, 113, 28;
+  --bs-form-warning-color: #f2711c;
+  --bs-form-warning-border-color: #f2711c;
+}
+
+input,
+textarea,
+select,
+.form-control {
+  &[disabled] {
+    & ~ .warning-feedback {
+      display: none;
+    }
+  }
+  &:not([disabled]) {
+    &:not(input[type="checkbox"]):not(input[type="radio"]) {
+      background: none !important;
+      padding-right: revert !important;
+    }
+
+    & ~ .warning-feedback {
+      @extend .invalid-feedback;
+      color: var(--bs-form-warning-color);
+      display: block;
+    }
+  }
+}
+
+input.form-control,
+textarea.form-control,
+select.form-select,
+.form-control,
+.form-check,
+.form-check-input {
+  &.is-warning:not([disabled]) {
+    @extend .is-invalid;
+
+    border-color: var(--bs-form-warning-border-color);
+  }
+
+  &.is-warning:focus:not([disabled]) {
+    @extend .is-invalid, :focus;
+
+    border-color: var(--bs-form-warning-border-color);
+    box-shadow: 0 0 0 0.25rem rgba(var(--bs-form-warning-rgb), 0.25);
+  }
+}
+
+.form-check-input.is-warning:not([disabled]) {
+  @extend .is-invalid;
+
+  &:checked {
+    &:focus,
+    & {
+      background-color: var(--bs-form-warning-color);
+    }
+  }
+
+  &:focus,
+  & {
+    & ~ .form-check-label {
+      color: var(--bs-form-warning-color);
+    }
+  }
+}
diff --git a/packages/ember/src/components/form/field.gts b/packages/ember/src/components/form/field.gts
index b367e6bff..fe05549cc 100644
--- a/packages/ember/src/components/form/field.gts
+++ b/packages/ember/src/components/form/field.gts
@@ -5,6 +5,7 @@ import Component from '@glimmer/component';
 import { tracked } from '@glimmer/tracking';
 import { runTask } from 'ember-lifeline';
 
+import PhoneField from './phone-field.gts';
 import RadioGroup from './radio-group.gts';
 import Select from './select.gts';
 import TextArea from './text-area.gts';
@@ -43,6 +44,7 @@ export interface FieldSignature {
   Blocks: {
     default: [
       {
+        Phone: ComponentLike<TextFieldSignature>;
         RadioGroup: ComponentLike<RadioGroupFieldSignature>;
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         Select: ComponentLike<SelectSignature<any>>;
@@ -109,6 +111,10 @@ export default class Field extends Component<FieldSignature> {
     return typeof this.errorMessage === 'string';
   }
 
+  get hasWarning() {
+    return typeof this.warningMessage === 'string';
+  }
+
   get errorMessage() {
     const { form } = this.args;
 
@@ -119,6 +125,16 @@ export default class Field extends Component<FieldSignature> {
     return form.errorFor(this.validatorKey);
   }
 
+  get warningMessage() {
+    const { form } = this.args;
+
+    if (!form) {
+      return undefined;
+    }
+
+    return form.warningFor(this.validatorKey);
+  }
+
   get validatorKey() {
     return this.args.validatorKey ?? this.binding.valuePath;
   }
@@ -126,7 +142,7 @@ export default class Field extends Component<FieldSignature> {
   get describedBy() {
     const describedBy = [];
 
-    if (this.hasError) {
+    if (this.hasError || this.hasWarning) {
       describedBy.push(this.messageId);
     }
 
@@ -195,6 +211,15 @@ export default class Field extends Component<FieldSignature> {
     </label>
     {{yield
       (hash
+        Phone=(component
+          PhoneField
+          describedBy=this.describedBy
+          disabled=@disabled
+          id=this.fieldId
+          initBinding=this.initBinding
+          isInvalid=this.hasError
+          isWarning=this.hasWarning
+        )
         RadioGroup=(component
           RadioGroup
           describedBy=this.describedBy
@@ -202,6 +227,7 @@ export default class Field extends Component<FieldSignature> {
           id=this.fieldId
           initBinding=this.initBinding
           isInvalid=this.hasError
+          isWarning=this.hasWarning
         )
         Select=(component
           this.TypedSelect
@@ -210,6 +236,7 @@ export default class Field extends Component<FieldSignature> {
           id=this.fieldId
           initBinding=this.initBinding
           isInvalid=this.hasError
+          isWarning=this.hasWarning
         )
         Text=(component Text field=this id=this.textId)
         TextArea=(component
@@ -219,6 +246,7 @@ export default class Field extends Component<FieldSignature> {
           id=this.fieldId
           initBinding=this.initBinding
           isInvalid=this.hasError
+          isWarning=this.hasWarning
         )
         TextField=(component
           TextField
@@ -227,13 +255,18 @@ export default class Field extends Component<FieldSignature> {
           id=this.fieldId
           initBinding=this.initBinding
           isInvalid=this.hasError
+          isWarning=this.hasWarning
         )
       )
     }}
     {{#if this.hasError}}
-      <div class="invalid-feedback" id={{this.messageId}}>
+      <div class="invalid-feedback" id={{this.describedBy}}>
         {{this.errorMessage}}
       </div>
+    {{else if this.hasWarning}}
+      <div class="warning-feedback" id={{this.describedBy}}>
+        {{this.warningMessage}}
+      </div>
     {{/if}}
   </template>
 }
diff --git a/packages/ember/src/components/form/index.gts b/packages/ember/src/components/form/index.gts
index 10f319c87..3e7a7bfb2 100644
--- a/packages/ember/src/components/form/index.gts
+++ b/packages/ember/src/components/form/index.gts
@@ -22,12 +22,12 @@ import type { ComponentLike } from '@glint/template';
 
 type Wrapper = {
   id: string;
-  v: Validator<unknown, unknown, unknown, unknown>;
+  v: Validator<unknown, object, object, object>;
 };
-type ValidatorArray = ValidatorBuilder<unknown, unknown, unknown, unknown>[];
+type ValidatorArray = ValidatorBuilder<unknown, object, object, object>[];
 type ValidatorsObject = Record<
   string,
-  ValidatorBuilder<unknown, unknown, unknown, unknown> | ValidatorArray
+  ValidatorBuilder<unknown, object, object, object> | ValidatorArray
 >;
 
 export interface FormType {
@@ -38,7 +38,7 @@ export interface FormType {
   warningFor(name: string): string | undefined;
   registerBinding(binding: Binding, name?: string): void;
   registerValidator(
-    validator: Validator<unknown, unknown, unknown, unknown>,
+    validator: Validator<unknown, object, object, object>,
     name?: string,
   ): string;
   unregisterValidator(name: string, id: string): void;
@@ -131,7 +131,9 @@ export default class Form extends Component<FormSignature> implements FormType {
     });
 
     const validations = Array.from(this.validations.values()).flat();
-    return validations.every((validator) => validator.v.result.isValid);
+    return validations
+      .filter((validator) => !validator.v.result.isWarning)
+      .every((validator) => validator.v.result.isValid);
   }
 
   submit = dropTask(async (event: SubmitEvent) => {
@@ -162,7 +164,7 @@ export default class Form extends Component<FormSignature> implements FormType {
 
   @action
   registerValidator(
-    validator: Validator<unknown, unknown, unknown, unknown>,
+    validator: Validator<unknown, object, object, object>,
     name?: string,
   ): string {
     const id = uid();
@@ -248,7 +250,8 @@ export default class Form extends Component<FormSignature> implements FormType {
     }
 
     const warning = validators.find(
-      (validator) => validator.v.result.isWarning,
+      (validator) =>
+        !validator.v.result.isValid && validator.v.result.isWarning,
     );
 
     if (!warning) {
diff --git a/packages/ember/src/components/form/phone-field.gts b/packages/ember/src/components/form/phone-field.gts
index 0f8c3cadd..5350a8ecd 100644
--- a/packages/ember/src/components/form/phone-field.gts
+++ b/packages/ember/src/components/form/phone-field.gts
@@ -107,11 +107,13 @@ export default class PhoneField extends TextField {
 
   <template>
     <input
+      aria-describedby={{@describedBy}}
       class={{this.classList}}
       disabled={{@disabled}}
+      id={{@id}}
       readonly={{@readonly}}
-      type="tel"
       maxlength="19"
+      type="tel"
       value={{this.displayValue}}
       {{onInsert this.onInsert}}
       {{on "input" this.change}}
diff --git a/packages/ember/src/components/form/radio-group.gts b/packages/ember/src/components/form/radio-group.gts
index 71246f2a5..a4655c6cb 100644
--- a/packages/ember/src/components/form/radio-group.gts
+++ b/packages/ember/src/components/form/radio-group.gts
@@ -16,6 +16,7 @@ export interface RadioGroupFieldSignature {
     disabled?: boolean;
     id?: string;
     isInvalid?: boolean;
+    isWarning?: boolean;
     name: string;
   };
   Blocks: {
@@ -27,14 +28,6 @@ export default class RadioGroupField extends BoundValue<
   RadioGroupFieldSignature,
   string
 > {
-  @action
-  change(updatedValue: Optional<string>) {
-    if (updatedValue) {
-      this.value = updatedValue;
-      this.onChange(updatedValue);
-    }
-  }
-
   get classList() {
     const classes = ['form-control'];
 
@@ -44,11 +37,25 @@ export default class RadioGroupField extends BoundValue<
 
     if (this.args.isInvalid) {
       classes.push('is-invalid');
+    } else if (this.args.isWarning) {
+      classes.push('is-warning');
     }
 
     return classes.join(' ');
   }
 
+  get name() {
+    return this.args.name ?? crypto.randomUUID();
+  }
+
+  @action
+  change(updatedValue: Optional<string>) {
+    if (updatedValue) {
+      this.value = updatedValue;
+      this.onChange(updatedValue);
+    }
+  }
+
   <template>
     <div
       aria-describedby={{@describedBy}}
@@ -63,7 +70,8 @@ export default class RadioGroupField extends BoundValue<
             currentValue=this.value
             disabled=@disabled
             isInvalid=@isInvalid
-            name=@name
+            isWarning=@isWarning
+            name=this.name
             onChange=this.change
           )
         )
@@ -78,6 +86,7 @@ export interface RadioFieldSignature {
     currentValue?: string | null;
     disabled?: boolean;
     isInvalid?: boolean;
+    isWarning?: boolean;
     label?: string;
     name: string;
     option?: string;
@@ -97,6 +106,8 @@ class RadioField extends Component<RadioFieldSignature> {
 
     if (this.args.isInvalid) {
       classes.push('is-invalid');
+    } else if (this.args.isWarning) {
+      classes.push('is-warning');
     }
 
     return classes.join(' ');
diff --git a/packages/ember/src/components/form/select.gts b/packages/ember/src/components/form/select.gts
index 5fce809b7..fd331b6ff 100644
--- a/packages/ember/src/components/form/select.gts
+++ b/packages/ember/src/components/form/select.gts
@@ -83,6 +83,7 @@ export interface SelectSignature<T> {
     displayPath?: string;
     id?: string;
     isInvalid?: boolean;
+    isWarning?: boolean;
     loading?: boolean;
     options: T[];
     scrollable?: boolean;
@@ -127,6 +128,8 @@ export default class Select<T> extends BoundValue<
 
     if (this.args.isInvalid) {
       classes.push('is-invalid');
+    } else if (this.args.isWarning) {
+      classes.push('is-warning');
     }
 
     return classes.join(' ');
diff --git a/packages/ember/src/components/form/text-area.gts b/packages/ember/src/components/form/text-area.gts
index a52d291cd..ae85c83ef 100644
--- a/packages/ember/src/components/form/text-area.gts
+++ b/packages/ember/src/components/form/text-area.gts
@@ -11,6 +11,7 @@ export interface TextAreaSignature {
     disabled?: boolean;
     id?: string;
     isInvalid?: boolean;
+    isWarning?: boolean;
     readonly?: boolean;
   };
 }
@@ -25,6 +26,8 @@ export default class TextArea extends BoundValue<TextAreaSignature, string> {
 
     if (this.args.isInvalid) {
       classes.push('is-invalid');
+    } else if (this.args.isWarning) {
+      classes.push('is-warning');
     }
 
     return classes.join(' ');
diff --git a/packages/ember/src/components/form/text-field.gts b/packages/ember/src/components/form/text-field.gts
index fc3859dba..5931f67df 100644
--- a/packages/ember/src/components/form/text-field.gts
+++ b/packages/ember/src/components/form/text-field.gts
@@ -11,6 +11,7 @@ export interface TextFieldSignature {
     disabled?: boolean;
     id?: string;
     isInvalid?: boolean;
+    isWarning?: boolean;
     readonly?: boolean;
   };
 }
@@ -25,6 +26,8 @@ export default class TextField extends BoundValue<TextFieldSignature, string> {
 
     if (this.args.isInvalid) {
       classes.push('is-invalid');
+    } else if (this.args.isWarning) {
+      classes.push('is-warning');
     }
 
     return classes.join(' ');
diff --git a/packages/ember/src/validation/index.ts b/packages/ember/src/validation/index.ts
index 1bd864a8a..579414f31 100644
--- a/packages/ember/src/validation/index.ts
+++ b/packages/ember/src/validation/index.ts
@@ -12,11 +12,8 @@ export { default as RegexValidator } from './validators/regex.ts';
 export { validator } from './utils.ts';
 
 export type {
+  BaseOptions,
   ComputedProperty,
-  DerivedOptions,
-  DerivedOptionValue,
-  Options,
-  OptionValue,
   TranslatableMessage,
   TranslatableOption,
   ValidateFnResponse,
diff --git a/packages/ember/src/validation/types.d.ts b/packages/ember/src/validation/types.d.ts
deleted file mode 100644
index a154b150b..000000000
--- a/packages/ember/src/validation/types.d.ts
+++ /dev/null
@@ -1,65 +0,0 @@
-import { Binding } from '../index.ts';
-
-export type ComputedProperty<Context> = (this: Context) => DerivedOptionValue;
-
-export interface DerivedOptions {
-  [key: string]: DerivedOptionValue;
-  message?: string;
-  isWarning?: boolean;
-}
-export type DerivedOptionValue =
-  | boolean
-  | number
-  | string
-  | Date
-  | undefined
-  | RegExp
-  | unknown[];
-
-export interface Options<Context> {
-  [key: string]: OptionValue<Context>;
-}
-export type OptionValue<Context> =
-  | ComputedProperty<Context, unknown>
-  | DerivedOptionValue;
-
-export interface TranslatableMessage {
-  key: string;
-  [option: string]: TranslatableOption;
-}
-
-export type TranslatableOption =
-  | string
-  | number
-  | boolean
-  | Date
-  | null
-  | undefined;
-
-export type ValidateFnResponse =
-  | boolean
-  | string
-  | TranslatableMessage
-  | ValidationResult;
-
-export interface ValidationResult {
-  isValid: boolean;
-  isWarning?: boolean;
-  message?: string;
-}
-
-export type ValidatorBuilder<T, Model, OptionsShape, Context> = (
-  binding: Binding<Model>,
-  context: Context,
-) => Validator<T, Model, OptionsShape, Context>;
-export interface Validator<T, Model, OptionsShape, Context> {
-  validate(
-    this: BaseValidator<T, Model, OptionsShape, Context>,
-    value: T,
-    options: OptionsShape,
-    context: Context | Model,
-  ): ValidateFnResponse;
-
-  readonly binding: Binding<Model>;
-  readonly result: ValidationResult;
-}
diff --git a/packages/ember/src/validation/types.ts b/packages/ember/src/validation/types.ts
new file mode 100644
index 000000000..9a8c2b174
--- /dev/null
+++ b/packages/ember/src/validation/types.ts
@@ -0,0 +1,66 @@
+import type BaseValidator from './validators/base.ts';
+import type { Binding } from '../index.ts';
+
+export type BaseOptions = {
+  disabled?: boolean;
+  key?: string;
+  message?: string;
+  isWarning?: boolean;
+};
+
+export type Computable<Context, Options> = {
+  [key in keyof Options]: ComputedProperty<Context, Options[key]>;
+};
+
+export type ComputedProperty<Context, T> = T | ((this: Context) => T);
+
+export interface TranslatableMessage extends Partial<ValidationResult> {
+  key: string;
+  [option: string]: TranslatableOption;
+}
+
+export type TranslatableOption =
+  | string
+  | number
+  | boolean
+  | Date
+  | null
+  | undefined;
+
+export type ValidateFnResponse =
+  | boolean
+  | string
+  | TranslatableMessage
+  | ValidationResult;
+
+export interface ValidationResult {
+  isValid: boolean;
+  isWarning?: boolean;
+  message?: string;
+}
+
+export type ValidatorBuilder<
+  T,
+  Model extends object,
+  Context extends object,
+  OptionsShape extends object,
+> = (
+  binding: Binding<Model>,
+  context: Context,
+) => Validator<T, Model, OptionsShape, Context>;
+export interface Validator<
+  T,
+  Model extends object,
+  Context extends object,
+  OptionsShape extends BaseOptions,
+> {
+  validate(
+    this: BaseValidator<T, Model, Context, OptionsShape>,
+    value: T,
+    options: OptionsShape,
+    context: Context | Model,
+  ): ValidateFnResponse;
+
+  readonly binding: Binding<Model>;
+  readonly result: ValidationResult;
+}
diff --git a/packages/ember/src/validation/utils.ts b/packages/ember/src/validation/utils.ts
index 16da16c30..cd402c1de 100644
--- a/packages/ember/src/validation/utils.ts
+++ b/packages/ember/src/validation/utils.ts
@@ -37,7 +37,7 @@ type ValidatorFnArgs<T extends ValidatorType = ValidatorType> = T extends T
 
 export function validator<V extends ValidatorType = ValidatorType>(
   ...[type, options]: ValidatorFnArgs<V>
-): ValidatorBuilder<unknown, ContextOf<V>, OptionsOf<V>, ContextOf<V>> {
+): ValidatorBuilder<unknown, ContextOf<V>, ContextOf<V>, OptionsOf<V>> {
   if (type === 'confirmation') {
     return (binding: Binding<ContextOf<V>>, context: ContextOf<V>) =>
       new ConfirmationValidator(
diff --git a/packages/ember/src/validation/validators/base.ts b/packages/ember/src/validation/validators/base.ts
index 1d86cc73d..2932bd38e 100644
--- a/packages/ember/src/validation/validators/base.ts
+++ b/packages/ember/src/validation/validators/base.ts
@@ -9,8 +9,8 @@ import { cached } from '@glimmer/tracking';
 
 import type { Binding } from '../../';
 import type {
-  DerivedOptions,
-  Options,
+  BaseOptions,
+  Computable,
   TranslatableMessage,
   ValidateFnResponse,
   ValidationResult,
@@ -34,26 +34,27 @@ export function unwrapProxy<T>(value: T): T {
 export default abstract class BaseValidator<
   T,
   Model extends object = Record<string, unknown>,
-  OptionsShape extends DerivedOptions = DerivedOptions,
   Context extends object = Record<string, unknown>,
-> implements Validator<T, Model, OptionsShape, Context>
+  OptionsShape extends BaseOptions = BaseOptions,
+> implements Validator<T, Model, Context, OptionsShape>
 {
   abstract validate(
-    this: BaseValidator<T, Model, OptionsShape, Context>,
+    this: BaseValidator<T, Model, Context, OptionsShape>,
     value: T,
     options: OptionsShape,
     context: Context | Model,
   ): ValidateFnResponse;
-  defaultOptions: OptionsShape = {} as OptionsShape;
+  defaultOptions: Computable<Context, OptionsShape & BaseOptions> =
+    {} as OptionsShape;
 
   readonly owner;
   readonly binding: Binding<Model>;
-  readonly options: OptionsShape;
+  readonly options: Computable<Context, OptionsShape & BaseOptions>;
   readonly context: Context | Model;
 
   constructor(
     binding: Binding<Model>,
-    options: OptionsShape,
+    options: Computable<Context, OptionsShape & BaseOptions>,
     context: Context,
   ) {
     this.binding = binding;
@@ -61,8 +62,13 @@ export default abstract class BaseValidator<
     this.context = context ?? binding.model;
 
     assert(
-      'The `validate` method must be implemented by subclasses of BaseValidator',
-      this.validate,
+      `You must provide a binding argument to ${this.constructor.name}`,
+      binding,
+    );
+
+    assert(
+      'BaseValidator requires the `validate` function to be implemented by subclasses',
+      typeof this.validate === 'function',
     );
 
     const owner = getOwner(this.context);
@@ -89,6 +95,11 @@ export default abstract class BaseValidator<
   get result(): ValidationResult {
     const { context, options, validate, value } = this;
     const computedOptions = this.computeOptions(options);
+
+    if (computedOptions.disabled) {
+      return { isValid: true };
+    }
+
     const response = validate.apply(this, [value, computedOptions, context]);
 
     return this.coalesceResponse(response, computedOptions);
@@ -98,30 +109,46 @@ export default abstract class BaseValidator<
     response: ValidateFnResponse,
     options: OptionsShape,
   ): ValidationResult {
+    let isValid = false;
+    let isWarning = options.isWarning;
+    let message = options.message;
+
     if (typeof response === 'boolean') {
-      return {
-        isValid: response,
-        isWarning: options.isWarning ?? false,
-        message: options.message,
-      };
+      isValid = response;
+    } else if (typeof response === 'string') {
+      message = response;
+    } else {
+      isValid = response.isValid ?? isValid;
+      isWarning ??= response.isWarning ?? isWarning;
     }
-    if (typeof response === 'string') {
-      return {
-        isValid: false,
-        isWarning: options.isWarning ?? false,
-        message: options.message ?? response,
-      };
+
+    isWarning ??= false;
+
+    if (options.key) {
+      const translationOptions = { ...options };
+      if (typeof response === 'object') {
+        Object.assign(translationOptions, response);
+      }
+
+      message = this.translateMessage({
+        ...translationOptions,
+        key: options.key,
+      });
+    } else if (options.message) {
+      message = options.message;
+    } else if (typeof response === 'object') {
+      message = response.message;
+
+      if ('key' in response && response.key) {
+        message = this.translateMessage({ ...options, ...response });
+      }
     }
-    if ('key' in response) {
-      const message = this.translateMessage(response);
-      return {
-        isValid: false,
-        isWarning: options.isWarning ?? false,
-        message,
-      };
+
+    if (isValid && !isWarning) {
+      message = undefined;
     }
 
-    return response;
+    return { isValid, isWarning, message };
   }
 
   translateMessage(message: TranslatableMessage): string {
@@ -130,18 +157,42 @@ export default abstract class BaseValidator<
     return this.intl.t(key, options);
   }
 
-  computeOptions(options: Options<Context>): OptionsShape {
-    const { context, defaultOptions } = this;
-    const computed: Record<string, unknown> = {};
+  computeOptions(options: Computable<Context, OptionsShape>) {
+    const { defaultOptions } = this;
+    const computed = {} as OptionsShape;
+
+    for (const key of Object.keys(options)) {
+      computed[key as keyof OptionsShape] = this.compute(
+        options[key as keyof OptionsShape],
+      );
+    }
+
+    for (const key of Object.keys(defaultOptions)) {
+      if (key in computed) {
+        continue;
+      }
 
-    for (const [key, value] of Object.entries(options)) {
-      if (typeof value === 'function') {
-        computed[key] = value.apply(context);
-      } else {
-        computed[key] = value;
+      const willOverrideMessage = key === 'key' && 'message' in computed;
+      const willOverrideKey = key === 'message' && 'key' in computed;
+      if (willOverrideMessage || willOverrideKey) {
+        continue;
       }
+
+      computed[key as keyof OptionsShape] = this.compute(
+        defaultOptions[key as keyof OptionsShape],
+      );
+    }
+
+    return { ...computed };
+  }
+
+  compute<K extends keyof OptionsShape>(
+    value: Computable<Context, OptionsShape>[K],
+  ): OptionsShape[K] {
+    if (typeof value === 'function') {
+      return value.apply(this.context);
     }
 
-    return { ...defaultOptions, ...computed } as OptionsShape;
+    return value as OptionsShape[K];
   }
 }
diff --git a/packages/ember/src/validation/validators/confirmation.ts b/packages/ember/src/validation/validators/confirmation.ts
index 7daeecc09..4a56dae3c 100644
--- a/packages/ember/src/validation/validators/confirmation.ts
+++ b/packages/ember/src/validation/validators/confirmation.ts
@@ -4,7 +4,12 @@ import { isEqual, isPresent } from '@ember/utils';
 import BaseValidator from './base.ts';
 
 import type { Binding } from '../../';
-import type { TranslatableOption, ValidateFnResponse } from '../types';
+import type {
+  BaseOptions,
+  Computable,
+  TranslatableOption,
+  ValidateFnResponse,
+} from '../types';
 
 export type ConfirmationOptions = {
   /**
@@ -16,20 +21,21 @@ export type ConfirmationOptions = {
    * The property name to compare the value against.
    */
   on: string;
-};
+} & BaseOptions;
 
 export default class ConfirmationValidator<
   Model extends object,
+  Context extends object = Record<string, TranslatableOption>,
 > extends BaseValidator<
   TranslatableOption,
   Model,
-  ConfirmationOptions,
-  Record<string, TranslatableOption>
+  Context,
+  ConfirmationOptions
 > {
   constructor(
     binding: Binding<Model>,
-    options: ConfirmationOptions,
-    context: Record<string, TranslatableOption>,
+    options: Computable<Context, ConfirmationOptions>,
+    context: Context,
   ) {
     super(binding, options, context);
 
@@ -44,11 +50,11 @@ export default class ConfirmationValidator<
   validate(
     value: TranslatableOption,
     options: ConfirmationOptions,
-    context: Record<string, TranslatableOption>,
+    context: Context,
   ): ValidateFnResponse {
     const { label, on } = options;
 
-    const expectedValue = context[on];
+    const expectedValue = (context as Record<string, TranslatableOption>)[on];
 
     if (isEqual(value, expectedValue)) {
       return true;
diff --git a/packages/ember/src/validation/validators/custom.ts b/packages/ember/src/validation/validators/custom.ts
index 687e01d2a..dc072d9fc 100644
--- a/packages/ember/src/validation/validators/custom.ts
+++ b/packages/ember/src/validation/validators/custom.ts
@@ -7,32 +7,36 @@ import BaseValidator from './base.ts';
 
 import type { Binding } from '../../';
 import type {
-  DerivedOptions,
+  BaseOptions,
+  Computable,
   ValidateFnResponse,
   ValidationResult,
 } from '../types';
 
-declare type ValidateFn<T> = (
+declare type ValidateFn<T, Context> = (
   value: T,
-  options: CustomOptions<T>,
+  options: CustomOptions<T, Context>,
   context: Record<string, unknown>,
 ) => ValidateFnResponse;
 
-export type CustomOptions<T> = {
+export type CustomOptions<T, Context> = {
   /**
    * The function to be called to validate. It should return a boolean or a
    * response object.
    */
-  validate: ValidateFn<T>;
-} & DerivedOptions;
+  validate: ValidateFn<T, Context>;
+} & BaseOptions;
 
 export default class CustomValidator<
   T,
   Model extends object,
-  Options extends CustomOptions<T> = CustomOptions<T>,
   Context extends object = Record<string, unknown>,
-> extends BaseValidator<T, Model, Options, Context> {
-  constructor(binding: Binding<Model>, options: Options, context: Context) {
+> extends BaseValidator<T, Model, Context, CustomOptions<T, Context>> {
+  constructor(
+    binding: Binding<Model>,
+    options: Computable<Context, CustomOptions<T, Context>>,
+    context: Context,
+  ) {
     super(binding, options, context);
 
     const { validate } = options;
@@ -47,19 +51,34 @@ export default class CustomValidator<
   get result(): ValidationResult {
     const { context, value } = this;
     const { validate, ...options } = this.options;
-    const computedOptions = this.computeOptions(options);
+    const computedOptions = this.computeOptions(
+      options as CustomOptions<T, Context>,
+    );
+
+    if (computedOptions.disabled) {
+      return { isValid: true };
+    }
 
-    let response = validate.apply(context, [
+    let response = (validate as ValidateFn<T, Context>).apply(context, [
       value,
       computedOptions,
       context as Record<string, unknown>,
     ]);
 
-    response = this.coalesceResponse(response, computedOptions);
+    const stringValue = String(value);
+    response = this.coalesceResponse(response, {
+      ...computedOptions,
+      // @ts-expect-error `value` is not an option defined on `CustomOptions`,
+      // but it is a valid option for the `coalesceResponse` method (which is
+      // is used for translations)
+      value: stringValue,
+    });
     if (!response.isValid) {
       response.message ??= this.intl.t('nrg.validation.custom.invalid', {
-        value: String(value),
+        value: stringValue,
       });
+
+      delete computedOptions.key;
     }
 
     return this.coalesceResponse(response, computedOptions);
diff --git a/packages/ember/src/validation/validators/exclusion.ts b/packages/ember/src/validation/validators/exclusion.ts
index 430216884..38bd95955 100644
--- a/packages/ember/src/validation/validators/exclusion.ts
+++ b/packages/ember/src/validation/validators/exclusion.ts
@@ -3,23 +3,23 @@ import { assert } from '@ember/debug';
 import BaseValidator from './base.ts';
 
 import type { Binding, Primitive } from '../../';
-import type { ValidateFnResponse } from '../types';
+import type { BaseOptions, Computable, ValidateFnResponse } from '../types';
 
 export type ExclusionOptions<T> = {
   /**
    * An array of invalid values.
    */
   in: T[];
-};
+} & BaseOptions;
 
 export default class ExclusionValidator<
   T extends Primitive,
-  Model extends object,
   Context extends object = Record<string, unknown>,
-> extends BaseValidator<T, Model, ExclusionOptions<T>, Context> {
+  Model extends object = Record<string, unknown>,
+> extends BaseValidator<T, Model, Context, ExclusionOptions<T>> {
   constructor(
     bind: Binding<Model>,
-    options: ExclusionOptions<T>,
+    options: Computable<Context, ExclusionOptions<T>>,
     context: Context,
   ) {
     super(bind, options, context);
diff --git a/packages/ember/src/validation/validators/inclusion.ts b/packages/ember/src/validation/validators/inclusion.ts
index 6bb2eb267..506054f31 100644
--- a/packages/ember/src/validation/validators/inclusion.ts
+++ b/packages/ember/src/validation/validators/inclusion.ts
@@ -3,23 +3,23 @@ import { assert } from '@ember/debug';
 import BaseValidator from './base.ts';
 
 import type { Binding, Primitive } from '../../';
-import type { ValidateFnResponse } from '../types';
+import type { BaseOptions, Computable, ValidateFnResponse } from '../types';
 
 export type InclusionOptions<T> = {
   /**
    * An array of valid values.
    */
   in: T[];
-};
+} & BaseOptions;
 
 export default class InclusionValidator<
   T extends Primitive,
   Model extends object,
   Context extends object = Record<string, unknown>,
-> extends BaseValidator<T, Model, InclusionOptions<T>, Context> {
+> extends BaseValidator<T, Model, Context, InclusionOptions<T>> {
   constructor(
     binding: Binding<Model>,
-    options: InclusionOptions<T>,
+    options: Computable<Context, InclusionOptions<T>>,
     context: Context,
   ) {
     super(binding, options, context);
diff --git a/packages/ember/src/validation/validators/length.ts b/packages/ember/src/validation/validators/length.ts
index 148ef2c02..90746e40b 100644
--- a/packages/ember/src/validation/validators/length.ts
+++ b/packages/ember/src/validation/validators/length.ts
@@ -4,7 +4,7 @@ import { isEmpty, isNone } from '@ember/utils';
 import BaseValidator from './base.ts';
 
 import type { Binding } from '../../';
-import type { ValidateFnResponse } from '../types';
+import type { BaseOptions, Computable, ValidateFnResponse } from '../types';
 
 export type LengthOptions = {
   /**
@@ -22,13 +22,13 @@ export type LengthOptions = {
   is?: number;
   max?: number;
   min?: number;
-};
+} & BaseOptions;
 
 export default class LengthValidator<
   T extends ArrayLike<T>,
   Model extends object,
   Context extends object = Record<string, unknown>,
-> extends BaseValidator<T, Model, LengthOptions, Context> {
+> extends BaseValidator<T, Model, Context, LengthOptions> {
   defaultOptions = {
     allowNone: true,
     presence: true,
@@ -36,7 +36,7 @@ export default class LengthValidator<
 
   constructor(
     binding: Binding<Model>,
-    options: LengthOptions,
+    options: Computable<Context, LengthOptions>,
     context: Context,
   ) {
     super(binding, options, context);
diff --git a/packages/ember/src/validation/validators/number.ts b/packages/ember/src/validation/validators/number.ts
index d0ea5632a..0859f4a02 100644
--- a/packages/ember/src/validation/validators/number.ts
+++ b/packages/ember/src/validation/validators/number.ts
@@ -2,7 +2,7 @@ import { isEmpty, isNone } from '@ember/utils';
 
 import BaseValidator from './base.ts';
 
-import type { ValidateFnResponse } from '../types';
+import type { BaseOptions, ValidateFnResponse } from '../types';
 
 export type NumberOptions = {
   /**
@@ -53,14 +53,14 @@ export type NumberOptions = {
    * When set, the number must be exactly this value
    */
   is?: number;
-};
+} & BaseOptions;
 
 declare type NumberLike = number | string | null | undefined;
 
 export default class NumberValidator<
   Model extends object,
   Context extends object = Record<string, unknown>,
-> extends BaseValidator<NumberLike, Model, NumberOptions, Context> {
+> extends BaseValidator<NumberLike, Model, Context, NumberOptions> {
   defaultOptions = {
     allowNone: true,
   };
diff --git a/packages/ember/src/validation/validators/presence.ts b/packages/ember/src/validation/validators/presence.ts
index 7a4e09d38..4bf8a0d0e 100644
--- a/packages/ember/src/validation/validators/presence.ts
+++ b/packages/ember/src/validation/validators/presence.ts
@@ -4,7 +4,7 @@ import { isEmpty, isPresent } from '@ember/utils';
 import BaseValidator from './base.ts';
 
 import type { Binding } from '../../';
-import type { ValidateFnResponse } from '../types';
+import type { BaseOptions, Computable, ValidateFnResponse } from '../types';
 
 export type PresenceOptions = {
   /**
@@ -17,13 +17,13 @@ export type PresenceOptions = {
    * @default false
    */
   ignoreBlank?: boolean;
-};
+} & BaseOptions;
 
 export default class PresenceValidator<
   T,
   Model extends object,
   Context extends object = Record<string, unknown>,
-> extends BaseValidator<T, Model, PresenceOptions, Context> {
+> extends BaseValidator<T, Model, Context, PresenceOptions> {
   defaultOptions = {
     presence: true,
     ignoreBlank: false,
@@ -31,7 +31,7 @@ export default class PresenceValidator<
 
   constructor(
     binding: Binding<Model>,
-    options: PresenceOptions,
+    options: Computable<Context, PresenceOptions>,
     context: Context,
   ) {
     super(binding, options, context);
diff --git a/packages/ember/src/validation/validators/range.ts b/packages/ember/src/validation/validators/range.ts
index e8bc1dbbc..a0e0aa42c 100644
--- a/packages/ember/src/validation/validators/range.ts
+++ b/packages/ember/src/validation/validators/range.ts
@@ -4,7 +4,7 @@ import { isPresent } from '@ember/utils';
 import BaseValidator from './base.ts';
 
 import type { Binding } from '../../';
-import type { ValidateFnResponse } from '../types';
+import type { BaseOptions, Computable, ValidateFnResponse } from '../types';
 
 export type RangeOptions = {
   /**
@@ -25,12 +25,12 @@ export type RangeOptions = {
    * @default true
    */
   maxInclusive?: boolean;
-};
+} & BaseOptions;
 
 export default class RangeValidator<
   Model extends object,
   Context extends object = Record<string, unknown>,
-> extends BaseValidator<number, Model, RangeOptions, Context> {
+> extends BaseValidator<number, Model, Context, RangeOptions> {
   defaultOptions = {
     minInclusive: true,
     maxInclusive: true,
@@ -38,7 +38,7 @@ export default class RangeValidator<
 
   constructor(
     binding: Binding<Model>,
-    options: RangeOptions,
+    options: Computable<Context, RangeOptions>,
     context: Context,
   ) {
     super(binding, options, context);
diff --git a/packages/ember/src/validation/validators/regex.ts b/packages/ember/src/validation/validators/regex.ts
index 452c5dcc9..cf0b7456f 100644
--- a/packages/ember/src/validation/validators/regex.ts
+++ b/packages/ember/src/validation/validators/regex.ts
@@ -4,7 +4,7 @@ import { isNone } from '@ember/utils';
 import BaseValidator from './base.ts';
 
 import type { Binding } from '../..';
-import type { ValidateFnResponse } from '../types';
+import type { BaseOptions, Computable, ValidateFnResponse } from '../types';
 
 export type RegexOptions = {
   /**
@@ -16,15 +16,15 @@ export type RegexOptions = {
    * A regular expression pattern that the value must match.
    */
   pattern: RegExp | string;
-};
+} & BaseOptions;
 
 export default class RegexValidator<
   Model extends object = Record<string, unknown>,
   Context extends object = Record<string, unknown>,
-> extends BaseValidator<string, Model, RegexOptions, Context> {
+> extends BaseValidator<string, Model, Context, RegexOptions> {
   constructor(
     binding: Binding<Model>,
-    options: RegexOptions,
+    options: Computable<Context, RegexOptions>,
     context: Context,
   ) {
     super(binding, options, context);
@@ -35,11 +35,6 @@ export default class RegexValidator<
       'RegexValidator requires `pattern` to be provided',
       !isNone(pattern),
     );
-
-    assert(
-      'RegexValidator requires the pattern to be of type string or RegExp',
-      typeof pattern === 'string' || pattern instanceof RegExp,
-    );
   }
 
   validate(value: string, options: RegexOptions): ValidateFnResponse {
@@ -50,6 +45,11 @@ export default class RegexValidator<
       !isNone(pattern),
     );
 
+    assert(
+      'RegexValidator requires the pattern to be of type string or RegExp',
+      typeof pattern === 'string' || pattern instanceof RegExp,
+    );
+
     const regex = typeof pattern === 'string' ? new RegExp(pattern) : pattern;
     const isValid = regex.test(value) === !inverse;