diff --git a/addon-test-support/@ember/test-helpers/-internal/helper-hooks.ts b/addon-test-support/@ember/test-helpers/-internal/helper-hooks.ts
deleted file mode 100644
index 1804a4a6e..000000000
--- a/addon-test-support/@ember/test-helpers/-internal/helper-hooks.ts
+++ /dev/null
@@ -1,78 +0,0 @@
-type Hook = (...args: any[]) => void | Promise<void>;
-type HookLabel = 'start' | 'end' | string;
-type HookUnregister = {
-  unregister: () => void;
-};
-
-const registeredHooks = new Map<string, Set<Hook>>();
-
-/**
- * @private
- * @param {string} helperName The name of the test helper in which to run the hook.
- * @param {string} label A label to help identify the hook.
- * @returns {string} The compound key for the helper.
- */
-function getHelperKey(helperName: string, label: string): string {
-  return `${helperName}:${label}`;
-}
-
-/**
- * Registers a hook function to be run during the invocation of a test helper.
- *
- * @private
- * @param {string} helperName The name of the test helper in which to run the hook.
- * @param {string} label A label to help identify the hook. Built-in labels are `start` and `end`,
- *                       designating the start of the helper invocation and the end.
- * @param {Function} hook The hook function to run when the test helper is invoked.
- * @returns {HookUnregister} An object containing an unregister function that will unregister
- *                           the specific hook registered to the helper.
- */
-export function registerHook(
-  helperName: string,
-  label: HookLabel,
-  hook: Hook
-): HookUnregister {
-  let helperKey = getHelperKey(helperName, label);
-  let hooksForHelper = registeredHooks.get(helperKey);
-
-  if (hooksForHelper === undefined) {
-    hooksForHelper = new Set<Hook>();
-    registeredHooks.set(helperKey, hooksForHelper);
-  }
-
-  hooksForHelper.add(hook);
-
-  return {
-    unregister() {
-      hooksForHelper!.delete(hook);
-    },
-  };
-}
-
-/**
- * Runs all hooks registered for a specific test helper.
- *
- * @private
- * @param {string} helperName  The name of the test helper.
- * @param {string} label A label to help identify the hook. Built-in labels are `start` and `end`,
- *                       designating the start of the helper invocation and the end.
- * @param {any[]} args Any arguments originally passed to the test helper.
- * @returns {Promise<void>} A promise representing the serial invocation of the hooks.
- */
-export function runHooks(
-  helperName: string,
-  label: HookLabel,
-  ...args: any[]
-): Promise<void> {
-  let hooks =
-    registeredHooks.get(getHelperKey(helperName, label)) || new Set<Hook>();
-  let promises: Array<void | Promise<void>> = [];
-
-  hooks.forEach((hook) => {
-    let hookResult = hook(...args);
-
-    promises.push(hookResult);
-  });
-
-  return Promise.all(promises).then(() => {});
-}
diff --git a/addon-test-support/@ember/test-helpers/dom/blur.ts b/addon-test-support/@ember/test-helpers/dom/blur.ts
index 56de6904f..6859c5658 100644
--- a/addon-test-support/@ember/test-helpers/dom/blur.ts
+++ b/addon-test-support/@ember/test-helpers/dom/blur.ts
@@ -4,7 +4,7 @@ import settled from '../settled';
 import Target from './-target';
 import { log } from '@ember/test-helpers/dom/-logging';
 import isFocusable from './-is-focusable';
-import { runHooks, registerHook } from '../-internal/helper-hooks';
+import { runHooks, registerHook } from '../helper-hooks';
 
 registerHook('blur', 'start', (target: Target) => {
   log('blur', target);
diff --git a/addon-test-support/@ember/test-helpers/dom/click.ts b/addon-test-support/@ember/test-helpers/dom/click.ts
index fe03b6c7c..ac63399a5 100644
--- a/addon-test-support/@ember/test-helpers/dom/click.ts
+++ b/addon-test-support/@ember/test-helpers/dom/click.ts
@@ -5,7 +5,7 @@ import settled from '../settled';
 import isFormControl from './-is-form-control';
 import Target, { isWindow } from './-target';
 import { log } from '@ember/test-helpers/dom/-logging';
-import { runHooks, registerHook } from '../-internal/helper-hooks';
+import { runHooks, registerHook } from '../helper-hooks';
 
 const PRIMARY_BUTTON = 1;
 const MAIN_BUTTON_PRESSED = 0;
diff --git a/addon-test-support/@ember/test-helpers/dom/double-click.ts b/addon-test-support/@ember/test-helpers/dom/double-click.ts
index bbb558d14..9575e0f32 100644
--- a/addon-test-support/@ember/test-helpers/dom/double-click.ts
+++ b/addon-test-support/@ember/test-helpers/dom/double-click.ts
@@ -6,7 +6,7 @@ import { DEFAULT_CLICK_OPTIONS } from './click';
 import Target, { isWindow } from './-target';
 import { log } from '@ember/test-helpers/dom/-logging';
 import isFormControl from './-is-form-control';
-import { runHooks, registerHook } from '../-internal/helper-hooks';
+import { runHooks, registerHook } from '../helper-hooks';
 
 registerHook('doubleClick', 'start', (target: Target) => {
   log('doubleClick', target);
diff --git a/addon-test-support/@ember/test-helpers/dom/fill-in.ts b/addon-test-support/@ember/test-helpers/dom/fill-in.ts
index c3ff2c67b..77d929670 100644
--- a/addon-test-support/@ember/test-helpers/dom/fill-in.ts
+++ b/addon-test-support/@ember/test-helpers/dom/fill-in.ts
@@ -6,7 +6,7 @@ import settled from '../settled';
 import fireEvent from './fire-event';
 import Target, { isContentEditable } from './-target';
 import { log } from '@ember/test-helpers/dom/-logging';
-import { runHooks, registerHook } from '../-internal/helper-hooks';
+import { runHooks, registerHook } from '../helper-hooks';
 
 registerHook('fillIn', 'start', (target: Target, text: string) => {
   log('fillIn', target, text);
diff --git a/addon-test-support/@ember/test-helpers/dom/fire-event.ts b/addon-test-support/@ember/test-helpers/dom/fire-event.ts
index 1fca4495c..6f8698891 100644
--- a/addon-test-support/@ember/test-helpers/dom/fire-event.ts
+++ b/addon-test-support/@ember/test-helpers/dom/fire-event.ts
@@ -2,7 +2,7 @@ import { isDocument, isElement } from './-target';
 import tuple from '../-tuple';
 import Target from './-target';
 import { log } from '@ember/test-helpers/dom/-logging';
-import { runHooks, registerHook } from '../-internal/helper-hooks';
+import { runHooks, registerHook } from '../helper-hooks';
 
 registerHook('fireEvent', 'start', (target: Target) => {
   log('fireEvent', target);
diff --git a/addon-test-support/@ember/test-helpers/dom/focus.ts b/addon-test-support/@ember/test-helpers/dom/focus.ts
index f3be9d767..4c83c86fb 100644
--- a/addon-test-support/@ember/test-helpers/dom/focus.ts
+++ b/addon-test-support/@ember/test-helpers/dom/focus.ts
@@ -4,7 +4,7 @@ import settled from '../settled';
 import isFocusable from './-is-focusable';
 import Target, { isDocument } from './-target';
 import { log } from '@ember/test-helpers/dom/-logging';
-import { runHooks, registerHook } from '../-internal/helper-hooks';
+import { runHooks, registerHook } from '../helper-hooks';
 import { __blur__ } from './blur';
 
 registerHook('focus', 'start', (target: Target) => {
diff --git a/addon-test-support/@ember/test-helpers/dom/scroll-to.ts b/addon-test-support/@ember/test-helpers/dom/scroll-to.ts
index 744a08910..08f58f6bf 100644
--- a/addon-test-support/@ember/test-helpers/dom/scroll-to.ts
+++ b/addon-test-support/@ember/test-helpers/dom/scroll-to.ts
@@ -2,7 +2,7 @@ import getElement from './-get-element';
 import fireEvent from './fire-event';
 import settled from '../settled';
 import { isElement } from './-target';
-import { runHooks } from '../-internal/helper-hooks';
+import { runHooks } from '../helper-hooks';
 
 /**
   Scrolls DOM element or selector to the given coordinates.
diff --git a/addon-test-support/@ember/test-helpers/dom/select.ts b/addon-test-support/@ember/test-helpers/dom/select.ts
index b357f2a77..1da3b985d 100644
--- a/addon-test-support/@ember/test-helpers/dom/select.ts
+++ b/addon-test-support/@ember/test-helpers/dom/select.ts
@@ -4,7 +4,7 @@ import { __focus__ } from './focus';
 import settled from '../settled';
 import fireEvent from './fire-event';
 import Target from './-target';
-import { runHooks } from '../-internal/helper-hooks';
+import { runHooks } from '../helper-hooks';
 
 /**
   Set the `selected` property true for the provided option the target is a
diff --git a/addon-test-support/@ember/test-helpers/dom/tab.ts b/addon-test-support/@ember/test-helpers/dom/tab.ts
index 22f9d802f..52b45c326 100644
--- a/addon-test-support/@ember/test-helpers/dom/tab.ts
+++ b/addon-test-support/@ember/test-helpers/dom/tab.ts
@@ -5,7 +5,7 @@ import Target, { isDocument } from './-target';
 import { __blur__ } from './blur';
 import { __focus__ } from './focus';
 import { isVisible, isDisabled } from '../-utils';
-import { registerHook, runHooks } from '../-internal/helper-hooks';
+import { registerHook, runHooks } from '../helper-hooks';
 import { log } from './-logging';
 
 const SUPPORTS_INERT = 'inert' in Element.prototype;
diff --git a/addon-test-support/@ember/test-helpers/dom/tap.ts b/addon-test-support/@ember/test-helpers/dom/tap.ts
index 6a049e162..a47d48db2 100644
--- a/addon-test-support/@ember/test-helpers/dom/tap.ts
+++ b/addon-test-support/@ember/test-helpers/dom/tap.ts
@@ -5,7 +5,7 @@ import settled from '../settled';
 import Target from './-target';
 import { log } from '@ember/test-helpers/dom/-logging';
 import isFormControl from './-is-form-control';
-import { runHooks, registerHook } from '../-internal/helper-hooks';
+import { runHooks, registerHook } from '../helper-hooks';
 
 registerHook('tap', 'start', (target: Target) => {
   log('tap', target);
diff --git a/addon-test-support/@ember/test-helpers/dom/trigger-event.ts b/addon-test-support/@ember/test-helpers/dom/trigger-event.ts
index c19bb6ff8..2a40592e8 100644
--- a/addon-test-support/@ember/test-helpers/dom/trigger-event.ts
+++ b/addon-test-support/@ember/test-helpers/dom/trigger-event.ts
@@ -4,7 +4,7 @@ import settled from '../settled';
 import Target from './-target';
 import { log } from '@ember/test-helpers/dom/-logging';
 import isFormControl from './-is-form-control';
-import { runHooks, registerHook } from '../-internal/helper-hooks';
+import { runHooks, registerHook } from '../helper-hooks';
 
 registerHook('triggerEvent', 'start', (target: Target, eventType: string) => {
   log('triggerEvent', target, eventType);
diff --git a/addon-test-support/@ember/test-helpers/dom/trigger-key-event.ts b/addon-test-support/@ember/test-helpers/dom/trigger-key-event.ts
index 0da4b9cf3..750337958 100644
--- a/addon-test-support/@ember/test-helpers/dom/trigger-key-event.ts
+++ b/addon-test-support/@ember/test-helpers/dom/trigger-key-event.ts
@@ -10,7 +10,7 @@ import { isNumeric } from '../-utils';
 import Target from './-target';
 import { log } from '@ember/test-helpers/dom/-logging';
 import isFormControl from './-is-form-control';
-import { runHooks, registerHook } from '../-internal/helper-hooks';
+import { runHooks, registerHook } from '../helper-hooks';
 
 registerHook(
   'triggerKeyEvent',
diff --git a/addon-test-support/@ember/test-helpers/dom/type-in.ts b/addon-test-support/@ember/test-helpers/dom/type-in.ts
index 88e04e9b1..a5743fcdf 100644
--- a/addon-test-support/@ember/test-helpers/dom/type-in.ts
+++ b/addon-test-support/@ember/test-helpers/dom/type-in.ts
@@ -11,7 +11,7 @@ import Target, {
 } from './-target';
 import { __triggerKeyEvent__ } from './trigger-key-event';
 import { log } from '@ember/test-helpers/dom/-logging';
-import { runHooks, registerHook } from '../-internal/helper-hooks';
+import { runHooks, registerHook } from '../helper-hooks';
 
 export interface Options {
   delay?: number;
diff --git a/addon-test-support/@ember/test-helpers/helper-hooks.ts b/addon-test-support/@ember/test-helpers/helper-hooks.ts
new file mode 100644
index 000000000..ef3a274e7
--- /dev/null
+++ b/addon-test-support/@ember/test-helpers/helper-hooks.ts
@@ -0,0 +1,95 @@
+export type Hook = (...args: any[]) => void | Promise<void>;
+export type HookLabel = 'start' | 'end' | 'targetFound';
+export type HookUnregister = {
+  unregister: () => void;
+};
+
+const registeredHooks = new Map<string, Set<Hook>>();
+
+/**
+ * @private
+ * @param {string} helperName The name of the test helper in which to run the hook.
+ * @param {string} label A label to help identify the hook.
+ * @returns {string} The compound key for the helper.
+ */
+function getHelperKey(helperName: string, label: string): string {
+  return `${helperName}:${label}`;
+}
+
+/**
+ * Registers a function to be run during the invocation of a test helper.
+ *
+ * @param {string} helperName The name of the test helper in which to run the hook.
+ *                            Test helper names include `blur`, `click`, `doubleClick`, `fillIn`,
+ *                            `fireEvent`, `focus`, `render`, `scrollTo`, `select`, `tab`, `tap`, `triggerEvent`,
+ *                            `triggerKeyEvent`, `typeIn`, and `visit`.
+ * @param {string} label A label to help identify the hook. Built-in labels include `start`, `end`,
+ *                       and `targetFound`, the former designating either the start or end of
+ *                       the helper invocation.
+ * @param {Function} hook The hook function to run when the test helper is invoked.
+ * @returns {HookUnregister} An object containing an `unregister` function that unregisters
+ *                           the specific hook initially registered to the helper.
+ * @example
+ * <caption>
+ *   Registering a hook for the `end` point of the `click` test helper invocation
+ * </caption>
+ *
+ * const hook = registerHook('click', 'end', () => {
+ *   console.log('Running `click:end` test helper hook');
+ * });
+ *
+ * // Unregister the hook at some later point in time
+ * hook.unregister();
+ */
+export function registerHook(
+  helperName: string,
+  label: HookLabel,
+  hook: Hook
+): HookUnregister {
+  let helperKey = getHelperKey(helperName, label);
+  let hooksForHelper = registeredHooks.get(helperKey);
+
+  if (hooksForHelper === undefined) {
+    hooksForHelper = new Set<Hook>();
+    registeredHooks.set(helperKey, hooksForHelper);
+  }
+
+  hooksForHelper.add(hook);
+
+  return {
+    unregister() {
+      hooksForHelper!.delete(hook);
+    },
+  };
+}
+
+/**
+ * Runs all hooks registered for a specific test helper.
+ *
+ * @param {string} helperName The name of the test helper in which to run the hook.
+ *                            Test helper names include `blur`, `click`, `doubleClick`, `fillIn`,
+ *                            `fireEvent`, `focus`, `render`, `scrollTo`, `select`, `tab`, `tap`, `triggerEvent`,
+ *                            `triggerKeyEvent`, `typeIn`, and `visit`.
+ * @param {string} label A label to help identify the hook. Built-in labels include `start`, `end`,
+ *                       and `targetFound`, the former designating either the start or end of
+ *                       the helper invocation.
+ * @param {unknown[]} args Any arguments originally passed to the test helper.
+ * @returns {Promise<void>} A promise representing the serial invocation of the hooks.
+ */
+export function runHooks(
+  helperName: string,
+  label: HookLabel,
+  ...args: unknown[]
+): Promise<void> {
+  let hooks =
+    registeredHooks.get(getHelperKey(helperName, label)) || new Set<Hook>();
+  let promises: Array<void | Promise<void>> = [];
+
+  hooks.forEach((hook) => {
+    let hookResult = hook(...args);
+
+    promises.push(hookResult);
+  });
+
+  return Promise.all(promises).then(() => {});
+}
diff --git a/addon-test-support/@ember/test-helpers/index.ts b/addon-test-support/@ember/test-helpers/index.ts
index db6fb7c30..efb926f2c 100644
--- a/addon-test-support/@ember/test-helpers/index.ts
+++ b/addon-test-support/@ember/test-helpers/index.ts
@@ -50,9 +50,12 @@ export { default as registerDebugInfoHelper } from './-internal/debug-info-helpe
 export type { TestMetadata } from './test-metadata';
 export { default as getTestMetadata } from './test-metadata';
 export {
-  registerHook as _registerHook,
-  runHooks as _runHooks,
-} from './-internal/helper-hooks';
+  registerHook,
+  runHooks,
+  type Hook,
+  type HookLabel,
+  type HookUnregister,
+} from './helper-hooks';
 
 // DOM Helpers
 export { default as click } from './dom/click';
diff --git a/addon-test-support/@ember/test-helpers/setup-application-context.ts b/addon-test-support/@ember/test-helpers/setup-application-context.ts
index 92f4af4c2..68b6e087e 100644
--- a/addon-test-support/@ember/test-helpers/setup-application-context.ts
+++ b/addon-test-support/@ember/test-helpers/setup-application-context.ts
@@ -9,7 +9,7 @@ import global from './global';
 import hasEmberVersion from './has-ember-version';
 import settled from './settled';
 import getTestMetadata from './test-metadata';
-import { runHooks } from './-internal/helper-hooks';
+import { runHooks } from './helper-hooks';
 import type Router from '@ember/routing/router';
 import type RouterService from '@ember/routing/router-service';
 import { assert } from '@ember/debug';
diff --git a/addon-test-support/@ember/test-helpers/setup-rendering-context.ts b/addon-test-support/@ember/test-helpers/setup-rendering-context.ts
index 83fb999d8..acd76b974 100644
--- a/addon-test-support/@ember/test-helpers/setup-rendering-context.ts
+++ b/addon-test-support/@ember/test-helpers/setup-rendering-context.ts
@@ -14,7 +14,7 @@ import getRootElement from './dom/get-root-element';
 import { Owner } from './build-owner';
 import getTestMetadata from './test-metadata';
 import { assert } from '@ember/debug';
-import { runHooks } from './-internal/helper-hooks';
+import { runHooks } from './helper-hooks';
 import hasEmberVersion from './has-ember-version';
 import isComponent from './-internal/is-component';
 import { macroCondition, dependencySatisfies } from '@embroider/macros';
diff --git a/tests/helpers/register-hooks.js b/tests/helpers/register-hooks.js
index 351864f36..ee9e37261 100644
--- a/tests/helpers/register-hooks.js
+++ b/tests/helpers/register-hooks.js
@@ -1,4 +1,4 @@
-import { _registerHook } from '@ember/test-helpers';
+import { registerHook } from '@ember/test-helpers';
 
 /**
  * Register mock hooks for a helper and optional list of expected events performed while the helper is executed.
@@ -11,10 +11,10 @@ import { _registerHook } from '@ember/test-helpers';
  */
 export const registerHooks = (assert, helperName, { expectedEvents } = {}) => {
   const mockHooks = [
-    _registerHook(helperName, 'start', () => {
+    registerHook(helperName, 'start', () => {
       assert.step(`${helperName}:start`);
     }),
-    _registerHook(helperName, 'end', () => {
+    registerHook(helperName, 'end', () => {
       assert.step(`${helperName}:end`);
     }),
   ];
@@ -35,19 +35,19 @@ export const registerHooks = (assert, helperName, { expectedEvents } = {}) => {
  * @returns {HookUnregister[]} Unregisterable hooks
  */
 export const registerFireEventHooks = (assert, expectedEvents) => {
-  const startHook = _registerHook('fireEvent', 'start', () => {
+  const startHook = registerHook('fireEvent', 'start', () => {
     assert.step(`fireEvent:start`);
   });
-  const endHook = _registerHook('fireEvent', 'end', () => {
+  const endHook = registerHook('fireEvent', 'end', () => {
     assert.step(`fireEvent:end`);
   });
 
   const eventTypes = [...new Set(expectedEvents)];
   const eventSpecificHooks = eventTypes.flatMap((eventType) => [
-    _registerHook(`fireEvent:${eventType}`, 'start', () => {
+    registerHook(`fireEvent:${eventType}`, 'start', () => {
       assert.step(`fireEvent:${eventType}:start`);
     }),
-    _registerHook(`fireEvent:${eventType}`, 'end', () => {
+    registerHook(`fireEvent:${eventType}`, 'end', () => {
       assert.step(`fireEvent:${eventType}:end`);
     }),
   ]);
diff --git a/tests/unit/dom/blur-test.js b/tests/unit/dom/blur-test.js
index 0d41162ab..acfe8a21f 100644
--- a/tests/unit/dom/blur-test.js
+++ b/tests/unit/dom/blur-test.js
@@ -4,7 +4,7 @@ import {
   blur,
   setupContext,
   teardownContext,
-  _registerHook,
+  registerHook,
 } from '@ember/test-helpers';
 import { buildInstrumentedElement, insertElement } from '../../helpers/events';
 import { isEdge } from '../../helpers/browser-detect';
@@ -59,10 +59,10 @@ module('DOM Helper: blur', function (hooks) {
 
     await focus(element);
 
-    let startHook = _registerHook('blur', 'start', () => {
+    let startHook = registerHook('blur', 'start', () => {
       assert.step('blur:start');
     });
-    let endHook = _registerHook('blur', 'end', () => {
+    let endHook = registerHook('blur', 'end', () => {
       assert.step('blur:end');
     });
 
diff --git a/tests/unit/dom/focus-test.js b/tests/unit/dom/focus-test.js
index b54e3a98c..b81148d63 100644
--- a/tests/unit/dom/focus-test.js
+++ b/tests/unit/dom/focus-test.js
@@ -3,7 +3,7 @@ import {
   focus,
   setupContext,
   teardownContext,
-  _registerHook,
+  registerHook,
 } from '@ember/test-helpers';
 import {
   buildInstrumentedElement,
@@ -51,10 +51,10 @@ module('DOM Helper: focus', function (hooks) {
     element = document.createElement('input');
     insertElement(element);
 
-    let startHook = _registerHook('focus', 'start', () => {
+    let startHook = registerHook('focus', 'start', () => {
       assert.step('focus:start');
     });
-    let endHook = _registerHook('focus', 'end', () => {
+    let endHook = registerHook('focus', 'end', () => {
       assert.step('focus:end');
     });
 
diff --git a/tests/unit/dom/helper-hooks-test.js b/tests/unit/dom/helper-hooks-test.js
index 49cf02d29..64ae9a2b8 100644
--- a/tests/unit/dom/helper-hooks-test.js
+++ b/tests/unit/dom/helper-hooks-test.js
@@ -1,17 +1,17 @@
 import { module, test } from 'qunit';
 import { Promise } from 'rsvp';
-import { _registerHook, _runHooks, isSettled } from '@ember/test-helpers';
+import { registerHook, runHooks, isSettled } from '@ember/test-helpers';
 
 module('helper hooks', function () {
   test('it can register a hook for a helper', async function (assert) {
     let func = () => assert.step('click:start hook');
-    let hook = _registerHook('click', 'start', func);
+    let hook = registerHook('click', 'start', func);
 
     try {
-      await _runHooks('click', 'start');
+      await runHooks('click', 'start');
       assert.verifySteps(['click:start hook']);
 
-      await _runHooks('click', 'start');
+      await runHooks('click', 'start');
       assert.verifySteps(['click:start hook']);
     } finally {
       hook.unregister();
@@ -20,17 +20,17 @@ module('helper hooks', function () {
 
   test('it can register an unregister a hook for a helper', async function (assert) {
     let func = () => assert.step('click:start hook');
-    let hook = _registerHook('click', 'start', func);
+    let hook = registerHook('click', 'start', func);
 
     try {
-      await _runHooks('click', 'start');
+      await runHooks('click', 'start');
       assert.verifySteps(['click:start hook']);
 
-      await _runHooks('click', 'start');
+      await runHooks('click', 'start');
       assert.verifySteps(['click:start hook']);
 
       hook.unregister();
-      await _runHooks('click', 'start');
+      await runHooks('click', 'start');
       assert.verifySteps([]);
     } finally {
       hook.unregister();
@@ -48,11 +48,11 @@ module('helper hooks', function () {
         }, 100);
       });
     };
-    let hook = _registerHook('click', 'start', func);
+    let hook = registerHook('click', 'start', func);
 
     try {
       assert.step('running hooks for click:start');
-      await _runHooks('click', 'start');
+      await runHooks('click', 'start');
       assert.step('hooks finished for click:start');
 
       assert.verifySteps([
@@ -67,15 +67,15 @@ module('helper hooks', function () {
   });
 
   test('it can run hooks for a helper by label', async function (assert) {
-    let fooHook1 = _registerHook('click', 'foo', () => {
+    let fooHook1 = registerHook('click', 'foo', () => {
       assert.step('click:foo1');
     });
-    let fooHook2 = _registerHook('click', 'foo', () => {
+    let fooHook2 = registerHook('click', 'foo', () => {
       assert.step('click:foo2');
     });
 
     try {
-      await _runHooks('click', 'foo');
+      await runHooks('click', 'foo');
 
       assert.verifySteps(['click:foo1', 'click:foo2']);
     } finally {
@@ -85,15 +85,15 @@ module('helper hooks', function () {
   });
 
   test('it is settled after runHooks resolves', async function (assert) {
-    await _runHooks('missing-thing', 'start');
+    await runHooks('missing-thing', 'start');
 
     assert.ok(isSettled(), 'is settled after runHooks with no hooks');
 
     let func = () => {};
-    let hook = _registerHook('present-thing', 'start', func);
+    let hook = registerHook('present-thing', 'start', func);
 
     try {
-      await _runHooks('click', 'start');
+      await runHooks('click', 'start');
 
       assert.ok(isSettled(), 'is settled after runHooks when a hook exists');
     } finally {
diff --git a/tests/unit/dom/trigger-event-test.js b/tests/unit/dom/trigger-event-test.js
index 792b5f476..29940f190 100644
--- a/tests/unit/dom/trigger-event-test.js
+++ b/tests/unit/dom/trigger-event-test.js
@@ -3,7 +3,7 @@ import {
   triggerEvent,
   setupContext,
   teardownContext,
-  _registerHook,
+  registerHook,
 } from '@ember/test-helpers';
 import { buildInstrumentedElement, insertElement } from '../../helpers/events';
 import hasEmberVersion from '@ember/test-helpers/has-ember-version';
@@ -44,10 +44,10 @@ module('DOM Helper: triggerEvent', function (hooks) {
     element = document.createElement('div');
     insertElement(element);
 
-    let startHook = _registerHook('triggerEvent', 'start', () => {
+    let startHook = registerHook('triggerEvent', 'start', () => {
       assert.step('triggerEvent:start');
     });
-    let endHook = _registerHook('triggerEvent', 'end', () => {
+    let endHook = registerHook('triggerEvent', 'end', () => {
       assert.step('triggerEvent:end');
     });
 
diff --git a/tests/unit/dom/trigger-key-event-test.js b/tests/unit/dom/trigger-key-event-test.js
index 3f30fe75d..f39359caf 100644
--- a/tests/unit/dom/trigger-key-event-test.js
+++ b/tests/unit/dom/trigger-key-event-test.js
@@ -3,7 +3,7 @@ import {
   triggerKeyEvent,
   setupContext,
   teardownContext,
-  _registerHook,
+  registerHook,
 } from '@ember/test-helpers';
 import { buildInstrumentedElement, insertElement } from '../../helpers/events';
 import hasEmberVersion from '@ember/test-helpers/has-ember-version';
@@ -44,10 +44,10 @@ module('DOM Helper: triggerKeyEvent', function (hooks) {
     element = document.createElement('div');
     insertElement(element);
 
-    let startHook = _registerHook('triggerKeyEvent', 'start', () => {
+    let startHook = registerHook('triggerKeyEvent', 'start', () => {
       assert.step('triggerKeyEvent:start');
     });
-    let endHook = _registerHook('triggerKeyEvent', 'end', () => {
+    let endHook = registerHook('triggerKeyEvent', 'end', () => {
       assert.step('triggerKeyEvent:end');
     });
 
diff --git a/tests/unit/setup-application-context-test.js b/tests/unit/setup-application-context-test.js
index 4c4052f21..c4cf39f86 100644
--- a/tests/unit/setup-application-context-test.js
+++ b/tests/unit/setup-application-context-test.js
@@ -12,7 +12,7 @@ import {
   visit,
   currentRouteName,
   currentURL,
-  _registerHook,
+  registerHook,
   isSettled,
 } from '@ember/test-helpers';
 import hasEmberVersion from '@ember/test-helpers/has-ember-version';
@@ -104,11 +104,11 @@ module('setupApplicationContext', function (hooks) {
   test('it executes registered visit hooks for start and end at the right time', async function (assert) {
     assert.expect(5);
 
-    let hookStart = _registerHook('visit', 'start', () => {
+    let hookStart = registerHook('visit', 'start', () => {
       assert.equal(currentURL(), null);
       assert.step('visit:start');
     });
-    let hookEnd = _registerHook('visit', 'end', () => {
+    let hookEnd = registerHook('visit', 'end', () => {
       assert.equal(currentURL(), '/');
       assert.step('visit:end');
     });
diff --git a/tests/unit/setup-rendering-context-test.js b/tests/unit/setup-rendering-context-test.js
index 72bdf05db..646d5c9e7 100644
--- a/tests/unit/setup-rendering-context-test.js
+++ b/tests/unit/setup-rendering-context-test.js
@@ -9,7 +9,7 @@ import {
   setupContext,
   setupRenderingContext,
   teardownContext,
-  _registerHook,
+  registerHook,
   getTestMetadata,
   render,
   clearRender,
@@ -180,10 +180,10 @@ module('setupRenderingContext', function (hooks) {
     test('it executes registered render hooks for start and end at the right time', async function (assert) {
       assert.expect(3);
 
-      let hookStart = _registerHook('render', 'start', () => {
+      let hookStart = registerHook('render', 'start', () => {
         assert.step('render:start');
       });
-      let hookEnd = _registerHook('render', 'end', () => {
+      let hookEnd = registerHook('render', 'end', () => {
         assert.step('render:end');
       });
 
diff --git a/type-tests/api.ts b/type-tests/api.ts
index c71a750ef..e0bbdde1d 100644
--- a/type-tests/api.ts
+++ b/type-tests/api.ts
@@ -67,6 +67,12 @@ import {
   DeprecationFailure,
   Warning,
   Target,
+  // Helper hooks
+  registerHook,
+  runHooks,
+  type Hook,
+  type HookLabel,
+  type HookUnregister,
 } from '@ember/test-helpers';
 import { ComponentInstance } from '@glimmer/interfaces';
 import { Owner } from '@ember/test-helpers/build-owner';
@@ -265,3 +271,11 @@ expectTypeOf(getWarnings).toEqualTypeOf<() => Array<Warning>>();
 expectTypeOf(getWarningsDuringCallback).toEqualTypeOf<
   (callback: () => void) => Array<Warning> | Promise<Array<Warning>>
 >();
+
+// Helper hooks
+expectTypeOf(registerHook).toEqualTypeOf<
+  (helperName: string, label: HookLabel, hook: Hook) => HookUnregister
+>();
+expectTypeOf(runHooks).toEqualTypeOf<
+  (helperName: string, label: HookLabel, ...args: unknown[]) => Promise<void>
+>();