@discourse/types 0.0.1 → 2026.1.0-a5a0839

package/external-types/@glint__template/-private/dsl/emit.d.ts

@@ -0,0 +1,178 @@
+declare module '@glint/template/-private/dsl/emit' {
+import { AttrValue, ContentValue } from '..';
+import {
+  ComponentReturn,
+  AnyContext,
+  AnyFunction,
+  ModifierReturn,
+  HasContext,
+  InvokableInstance,
+  TemplateContext,
+  NamedArgs,
+} from '../integration';
+import {
+  AttributesForElement,
+  ElementForTagName,
+  MathMlElementForTagName,
+  SVGElementForTagName,
+} from './types';
+
+/**
+ * Used during emit to denote an object literal that corresponds
+ * to the use of named args rather than passing an object value
+ * directly.
+ */
+export declare const NamedArgsMarker: NamedArgs<unknown>;
+
+/*
+ * Emits the given value as top-level content to the DOM. This:
+ *
+ *     Hello, {{world}}
+ *
+ * Would produce code like:
+ *
+ *     emitContent(resolveOrReturn(value)({}))
+ */
+export declare function emitContent(value: ContentValue): void;
+
+/*
+ * Emits an element of the given name, providing a value to the
+ * given handler of an appropriate type for the DOM node that will
+ * be produced. This:
+ *
+ *     <div ...attributes class="hello" {{on "click" this.clicked}}></div>
+ *
+ * Would produce code like:
+ *
+ *     emitElement('div', (__glintY__) => {
+ *       applySplattributes(__glintRef__.element, __glintY__.element);
+ *       applyAttributes(__glintY__.element, { class: 'hello' });
+ *       applyModifier(__glintY__.element, resolve(on)({}, 'click', this.clicked));
+ *     });
+ */
+export declare function emitElement<Name extends string | 'math' | 'svg'>(
+  name: Name,
+): {
+  element: Name extends 'math'
+    ? MathMlElementForTagName<'math'>
+    : Name extends 'svg'
+      ? SVGElementForTagName<'svg'>
+      : ElementForTagName<Name>;
+};
+
+export declare function emitSVGElement<Name extends keyof SVGElementTagNameMap>(
+  name: Name,
+): { element: SVGElementForTagName<Name> };
+
+export declare function emitMathMlElement<Name extends keyof MathMLElementTagNameMap>(
+  name: Name,
+): { element: MathMlElementForTagName<Name> };
+
+/*
+ * Emits the given value as an entity that expects to receive blocks
+ * rather than return a value. This corresponds to a block-form mustache
+ * statement or any angle-bracket component invocation, i.e.:
+ *
+ *     {{#value foo=bar}}{{/value}}
+ *     <Value @foo={{bar}} {{baz}}></Value>
+ *     <Value @foo={{bar}} {{baz}} />
+ *
+ * This form of invocation is the only one in a template that may have
+ * blocks bound to it. The final line above would produce code like:
+ *
+ *     emitComponent(resolve(Value)({ foo: bar })), (__glintY__) => {
+ *       applyModifier(__glintY__.element, resolve(baz)({}));
+ *     });
+ */
+export declare function emitComponent<T extends ComponentReturn<any, any>>(
+  component: T,
+): {
+  element: T extends ComponentReturn<any, infer El> ? El : any;
+  blockParams: T extends ComponentReturn<infer Yields, any> ? Required<Yields> : any;
+};
+
+/*
+ * Wraps a template body that appears as a standalone expression and is therefore not
+ * associated with any backing value.
+ *
+ * The given callback accepts a template context value as well as an instance of the
+ * environment's DSL export.
+ */
+export declare function templateExpression<
+  Signature extends AnyFunction = () => ComponentReturn<{}>,
+  Context extends AnyContext = TemplateContext<void, {}, {}, void>,
+>(
+  f: (__glintRef__: Context, __glintDSL__: never) => void,
+): new () => InvokableInstance<Signature> & HasContext<Context>;
+
+/*
+ * Wraps a template body that's backed by a known value (typically a class), either
+ * via a `.hbs` association to a default export or via embedding e.g. with `<template>`.
+ *
+ * The given callback accepts a template context value as well as an instance of the
+ * environment's DSL export.
+ *
+ * Note that this signature is structured carefully to trigger TypeScript's higher-order function
+ * type inference so that any type parameters on the given backing value (if it's a class) will
+ * be preserved and reflected in the template body. Both the `Args` type and the constructor return
+ * value are necessary for this, despite the fact that we don't actually do anything with those
+ * types (see https://github.com/microsoft/TypeScript/pull/30215).
+ */
+export declare function templateForBackingValue<Args extends unknown[], Context extends AnyContext>(
+  backingValue: abstract new (...args: Args) => HasContext<Context>,
+  body: (__glintRef__: Context, __glintDSL__: never) => void,
+): abstract new () => unknown;
+
+/*
+ * Used in template bodies to encode a `{{yield}}` statement.
+ *
+ *     {{yield foo bar to='name'}}
+ *
+ * Is equivalent to:
+ *
+ *     yieldToBlock(__glintRef__, 'name')(foo, bar);
+ */
+export declare function yieldToBlock<Context extends AnyContext, K extends keyof Context['blocks']>(
+  __glintRef__: Context,
+  to: K,
+): (...values: NonNullable<Context['blocks'][K]>) => void;
+
+/*
+ * Applies `...attributes` that were passed to a component down
+ * to an element or child component invocation in its template.
+ *
+ *     <div ...attributes></div>
+ *     <AnotherComponent ...attributes />
+ */
+export declare function applySplattributes<
+  SourceElement extends Element,
+  TargetElement extends SourceElement,
+>(source: SourceElement, target: TargetElement): void;
+
+/*
+ * Applies named attributes to an element or component.
+ *
+ *     <div foo={{bar}}></div>
+ *     <AnotherComponent foo={{bar}} />
+ */
+export declare function applyAttributes<T extends Element>(
+  element: T,
+  attrs: Partial<AttributesForElement<T>>,
+): void;
+
+/*
+ * Applies a modifier to an element or component.
+ *
+ *     <div {{someModifier}}></div>
+ *     <AnotherComponent {{someModifier}} />
+ */
+export declare function applyModifier(boundModifier: ModifierReturn): void;
+
+/*
+ * Used to consume imported identifiers like `hash` or `array` when
+ * we treat them as a special form to be translated into native
+ * syntax.
+ */
+export declare function noop(value: unknown): void;
+
+}

package/external-types/@glint__template/-private/dsl/lib.dom.augmentation.d.ts

@@ -0,0 +1,144 @@
+declare module '@glint/template/-private/dsl/lib.dom.augmentation' {
+// Auto-generated by bin/build-augmentations.mjs
+//
+// This serves to provide a UNIQUE mapping for element type -> element name -> element attributes
+//   (in combination with elements.d.ts)
+//
+// The TypeScript lib.dom.d.ts already has HTMLElementTagNameMap,
+// but it does not provide unique types for each element, and the technique
+// we use for looking up the type-string for each element does not work with the built in types.
+
+export type HTMLElementMap = {
+  'HTMLAnchorElement': HTMLAnchorElement;
+  'HTMLAreaElement': HTMLAreaElement;
+  'HTMLAudioElement': HTMLAudioElement;
+  'HTMLBRElement': HTMLBRElement;
+  'HTMLBaseElement': HTMLBaseElement;
+  'HTMLBodyElement': HTMLBodyElement;
+  'HTMLButtonElement': HTMLButtonElement;
+  'HTMLCanvasElement': HTMLCanvasElement;
+  'HTMLDListElement': HTMLDListElement;
+  'HTMLDataElement': HTMLDataElement;
+  'HTMLDataListElement': HTMLDataListElement;
+  'HTMLDetailsElement': HTMLDetailsElement;
+  'HTMLDialogElement': HTMLDialogElement;
+  'HTMLDivElement': HTMLDivElement;
+  'HTMLElement': HTMLElement;
+  'HTMLEmbedElement': HTMLEmbedElement;
+  'HTMLFieldSetElement': HTMLFieldSetElement;
+  'HTMLFormElement': HTMLFormElement;
+  'HTMLHRElement': HTMLHRElement;
+  'HTMLHeadElement': HTMLHeadElement;
+  'HTMLHeadingElement': HTMLHeadingElement;
+  'HTMLHtmlElement': HTMLHtmlElement;
+  'HTMLIFrameElement': HTMLIFrameElement;
+  'HTMLImageElement': HTMLImageElement;
+  'HTMLInputElement': HTMLInputElement;
+  'HTMLLIElement': HTMLLIElement;
+  'HTMLLabelElement': HTMLLabelElement;
+  'HTMLLegendElement': HTMLLegendElement;
+  'HTMLLinkElement': HTMLLinkElement;
+  'HTMLMapElement': HTMLMapElement;
+  'HTMLMenuElement': HTMLMenuElement;
+  'HTMLMetaElement': HTMLMetaElement;
+  'HTMLMeterElement': HTMLMeterElement;
+  'HTMLModElement': HTMLModElement;
+  'HTMLOListElement': HTMLOListElement;
+  'HTMLObjectElement': HTMLObjectElement;
+  'HTMLOptGroupElement': HTMLOptGroupElement;
+  'HTMLOptionElement': HTMLOptionElement;
+  'HTMLOutputElement': HTMLOutputElement;
+  'HTMLParagraphElement': HTMLParagraphElement;
+  'HTMLPictureElement': HTMLPictureElement;
+  'HTMLPreElement': HTMLPreElement;
+  'HTMLProgressElement': HTMLProgressElement;
+  'HTMLQuoteElement': HTMLQuoteElement;
+  'HTMLScriptElement': HTMLScriptElement;
+  'HTMLSelectElement': HTMLSelectElement;
+  'HTMLSlotElement': HTMLSlotElement;
+  'HTMLSourceElement': HTMLSourceElement;
+  'HTMLSpanElement': HTMLSpanElement;
+  'HTMLStyleElement': HTMLStyleElement;
+  'HTMLTableCaptionElement': HTMLTableCaptionElement;
+  'HTMLTableCellElement': HTMLTableCellElement;
+  'HTMLTableColElement': HTMLTableColElement;
+  'HTMLTableElement': HTMLTableElement;
+  'HTMLTableRowElement': HTMLTableRowElement;
+  'HTMLTableSectionElement': HTMLTableSectionElement;
+  'HTMLTemplateElement': HTMLTemplateElement;
+  'HTMLTextAreaElement': HTMLTextAreaElement;
+  'HTMLTimeElement': HTMLTimeElement;
+  'HTMLTitleElement': HTMLTitleElement;
+  'HTMLTrackElement': HTMLTrackElement;
+  'HTMLUListElement': HTMLUListElement;
+  'HTMLVideoElement': HTMLVideoElement;
+};
+
+export type SVGElementMap = {
+  'SVGAElement': SVGAElement;
+  'SVGAnimateElement': SVGAnimateElement;
+  'SVGAnimateMotionElement': SVGAnimateMotionElement;
+  'SVGAnimateTransformElement': SVGAnimateTransformElement;
+  'SVGCircleElement': SVGCircleElement;
+  'SVGClipPathElement': SVGClipPathElement;
+  'SVGDefsElement': SVGDefsElement;
+  'SVGDescElement': SVGDescElement;
+  'SVGElement': SVGElement;
+  'SVGEllipseElement': SVGEllipseElement;
+  'SVGFEBlendElement': SVGFEBlendElement;
+  'SVGFEColorMatrixElement': SVGFEColorMatrixElement;
+  'SVGFEComponentTransferElement': SVGFEComponentTransferElement;
+  'SVGFECompositeElement': SVGFECompositeElement;
+  'SVGFEConvolveMatrixElement': SVGFEConvolveMatrixElement;
+  'SVGFEDiffuseLightingElement': SVGFEDiffuseLightingElement;
+  'SVGFEDisplacementMapElement': SVGFEDisplacementMapElement;
+  'SVGFEDistantLightElement': SVGFEDistantLightElement;
+  'SVGFEDropShadowElement': SVGFEDropShadowElement;
+  'SVGFEFloodElement': SVGFEFloodElement;
+  'SVGFEFuncAElement': SVGFEFuncAElement;
+  'SVGFEFuncBElement': SVGFEFuncBElement;
+  'SVGFEFuncGElement': SVGFEFuncGElement;
+  'SVGFEFuncRElement': SVGFEFuncRElement;
+  'SVGFEGaussianBlurElement': SVGFEGaussianBlurElement;
+  'SVGFEImageElement': SVGFEImageElement;
+  'SVGFEMergeElement': SVGFEMergeElement;
+  'SVGFEMergeNodeElement': SVGFEMergeNodeElement;
+  'SVGFEMorphologyElement': SVGFEMorphologyElement;
+  'SVGFEOffsetElement': SVGFEOffsetElement;
+  'SVGFEPointLightElement': SVGFEPointLightElement;
+  'SVGFESpecularLightingElement': SVGFESpecularLightingElement;
+  'SVGFESpotLightElement': SVGFESpotLightElement;
+  'SVGFETileElement': SVGFETileElement;
+  'SVGFETurbulenceElement': SVGFETurbulenceElement;
+  'SVGFilterElement': SVGFilterElement;
+  'SVGForeignObjectElement': SVGForeignObjectElement;
+  'SVGGElement': SVGGElement;
+  'SVGImageElement': SVGImageElement;
+  'SVGLineElement': SVGLineElement;
+  'SVGLinearGradientElement': SVGLinearGradientElement;
+  'SVGMPathElement': SVGMPathElement;
+  'SVGMarkerElement': SVGMarkerElement;
+  'SVGMaskElement': SVGMaskElement;
+  'SVGMetadataElement': SVGMetadataElement;
+  'SVGPathElement': SVGPathElement;
+  'SVGPatternElement': SVGPatternElement;
+  'SVGPolygonElement': SVGPolygonElement;
+  'SVGPolylineElement': SVGPolylineElement;
+  'SVGRadialGradientElement': SVGRadialGradientElement;
+  'SVGRectElement': SVGRectElement;
+  'SVGSVGElement': SVGSVGElement;
+  'SVGScriptElement': SVGScriptElement;
+  'SVGSetElement': SVGSetElement;
+  'SVGStopElement': SVGStopElement;
+  'SVGStyleElement': SVGStyleElement;
+  'SVGSwitchElement': SVGSwitchElement;
+  'SVGSymbolElement': SVGSymbolElement;
+  'SVGTSpanElement': SVGTSpanElement;
+  'SVGTextElement': SVGTextElement;
+  'SVGTextPathElement': SVGTextPathElement;
+  'SVGTitleElement': SVGTitleElement;
+  'SVGUseElement': SVGUseElement;
+  'SVGViewElement': SVGViewElement;
+};
+
+}

package/external-types/@glint__template/-private/dsl/resolve.d.ts

@@ -0,0 +1,69 @@
+declare module '@glint/template/-private/dsl/resolve' {
+import { DirectInvokable, InvokableInstance, Invoke, InvokeDirect } from '../integration';
+import { ResolveOrReturn } from './types';
+
+/*
+ * We have multiple ways of representing invokable values, dictated by certain constraints
+ * of how TypeScript works. The purpose of `resolve` is to take any one of these types of
+ * values and return a function of the following form:
+ *
+ *     (args: Named, ...positional: Positional) => Result
+ *
+ * `Named` and `Positional` represent the respective types of the named and positional
+ * args accepted, and `Result` is either `CreatesModifier`, `ComponentReturn<...>`, or any
+ * other type to simply indicate that the invokable returns a value.
+ *
+ * In the core, invokables can take one of two forms:
+ *
+ *  - `new (...) => InvokableInstance<T>`: this is the typical signature for items such as a
+ *    component subclass. In resolving this form, we need to break apart the construct
+ *    signature and reconstruct it as a regular function, which has the implicit effect
+ *    of preserving type parameters for polymorphic components in the resulting function
+ *    type.
+ *  - `DirectInvokable<T>`: While items like component classes can't directly be invokable
+ *    themselves (among other things, their instance's type params wouldn't be in scope),
+ *    this form is useful for certain complex cases that may require explicitly declaring
+ *    a type rather than inferring it. Breaking apart and reconstructing a function
+ *    signature as we do above will cause functions with multipe signatures to collapse
+ *    down to their most general form, which breaks complex declarations like `fn` that
+ *    rely on having multiple overrides to be typed correctly.
+ *
+ * In modern Ember.js, plain functions can themselves be invokables with their
+ * own particular resolution semantics.
+ */
+
+export declare function resolve<T extends DirectInvokable>(item: T): T[typeof InvokeDirect];
+export declare function resolve<Args extends unknown[], Instance extends InvokableInstance>(
+  item: (abstract new (...args: Args) => Instance) | null | undefined,
+): (...args: Parameters<Instance[typeof Invoke]>) => ReturnType<Instance[typeof Invoke]>;
+
+/*
+ * A mustache like `{{this.foo}}` might either return a plain value like a string
+ * or number, or it might be an arg-less invocation of a helper (or even a curly
+ * component, depending on context).
+ *
+ * This variant of `resolve` is used for such mustaches, treating values with
+ * no associated signature as though they were arg-less helpers that return a
+ * value of the appropriate type.
+ */
+
+export declare const resolveOrReturn: ResolveOrReturn<typeof resolve>;
+
+/*
+ * Binding helpers like `{{component}}` and `{{helper}}` accept a variety of possible
+ * environment-specific initial arguments. This variant `resolve` signature allows
+ * environments to dictate how that argument is interpreted before being handed off to
+ * the actual helper definition. By resolving to the internal invokable form as described
+ * above, TypeScript can "do the right thing" in more cases for type inference, particularly
+ * with invokables whose signatures include type parameters.
+ */
+
+export declare function resolveForBind<T extends DirectInvokable>(item: T): T[typeof InvokeDirect];
+export declare function resolveForBind<Args extends unknown[], Instance extends InvokableInstance>(
+  item: abstract new (...args: Args) => Instance,
+): (...args: Parameters<Instance[typeof Invoke]>) => ReturnType<Instance[typeof Invoke]>;
+export declare function resolveForBind<Args extends unknown[], Instance extends InvokableInstance>(
+  item: null | undefined | (abstract new (...args: Args) => Instance),
+): null | ((...args: Parameters<Instance[typeof Invoke]>) => ReturnType<Instance[typeof Invoke]>);
+
+}

package/external-types/@glint__template/-private/dsl/types.d.ts

@@ -0,0 +1,63 @@
+declare module '@glint/template/-private/dsl/types' {
+import './elements';
+import { AttrValue } from '../index';
+import type { HTMLElementMap, SVGElementMap } from './lib.dom.augmentation';
+
+/**
+ * A utility for constructing the type of an environment's `resolveOrReturn` from
+ * the type of its `resolve` function.
+ */
+export type ResolveOrReturn<T> = T & (<U>(item: U) => () => U);
+
+/**
+ * Given a tag name, returns an appropriate `Element` subtype.
+ * NOTE: This will return a union for elements that exist both in HTML and SVG. Technically, this will be too permissive.
+ */
+export type ElementForTagName<Name extends string> = Name extends keyof HTMLElementTagNameMap
+  ? HTMLElementTagNameMap[Name]
+  : Element;
+
+export type SVGElementForTagName<Name extends string> = Name extends keyof SVGElementTagNameMap
+  ? SVGElementTagNameMap[Name]
+  : Element;
+
+export type MathMlElementForTagName<Name extends string> =
+  Name extends keyof MathMLElementTagNameMap ? MathMLElementTagNameMap[Name] : Element;
+
+/**
+ * This doesn't generate _totally_ unique mappings, but they all have the same attributes.
+ *
+ * For example, given T = HTMLDivElement,
+ * we get back:
+ *   - "HTMLTableCaptionElement"
+ *     | "HTMLDivElement"
+ *     | "HTMLHeadingElement"
+ *     | "HTMLParagraphElement"
+ *
+ * And for the purposes of attribute lookup, that's good enough.
+ */
+type HTMLElementLookup<T> = {
+  [K in keyof HTMLElementMap]: T extends HTMLElementMap[K]
+    ? HTMLElementMap[K] extends T
+      ? K
+      : never
+    : never;
+}[keyof HTMLElementMap];
+
+type SVGElementLookup<T> = {
+  [K in keyof SVGElementMap]: T extends SVGElementMap[K]
+    ? SVGElementMap[K] extends T
+      ? K
+      : never
+    : never;
+}[keyof SVGElementMap];
+
+type WithDataAttributes<T> = T & Record<`data-${string}`, AttrValue>;
+
+export type AttributesForElement<T extends Element> = T extends HTMLElement
+  ? WithDataAttributes<GlintHtmlElementAttributesMap[HTMLElementLookup<T>]>
+  : T extends SVGElement
+    ? WithDataAttributes<GlintSvgElementAttributesMap[SVGElementLookup<T>]>
+    : Record<string, AttrValue>;
+
+}

package/external-types/@glint__template/-private/dsl.d.ts

@@ -0,0 +1,10 @@
+declare module '@glint/template/-private/dsl' {
+// This module exports functions and types directly referenced by
+// the output of `ember-tsc`'s transform layer. It comprises the
+// basis from which environments construct their exports.
+
+export * from './dsl/emit';
+export * from './dsl/resolve';
+export * from './dsl/types';
+
+}

package/external-types/@glint__template/-private/index.d.ts

@@ -0,0 +1,187 @@
+declare module '@glint/template' {
+import {
+  ComponentReturn,
+  AnyFunction,
+  ModifierReturn,
+  FlattenBlockParams,
+  Invokable,
+  NamedArgNames,
+  UnwrapNamedArgs,
+} from './integration';
+import {
+  ComponentSignatureArgs,
+  ComponentSignatureBlocks,
+  ComponentSignatureElement,
+  Get,
+  InvokableArgs,
+  MaybeNamed,
+  PrebindArgs,
+  SliceFrom,
+} from './signature';
+
+/**
+ * Any value that can be safely emitted into the DOM as top-level content,
+ * i.e. as `<div>{{value}}</div>`.
+ *
+ * This includes primitives like strings, numbers and booleans; "nothing"
+ * values like `null` and `undefined`; DOM nodes; and blockless curly
+ * component invocations.
+ */
+export type ContentValue =
+  | string
+  | number
+  | boolean
+  | null
+  | undefined
+  | void
+  | SafeString
+  | Node
+  | ArglessCurlyComponent;
+
+// This encompasses both @glimmer/runtime and @ember/template's notion of `SafeString`s,
+// and this coverage is tested in `emit-content.test.ts`.
+type SafeString = { toHTML(): string };
+
+// `{{foo}}` becomes `emitContent(resolveOrReturn(foo)({})`, which means if `foo`
+// is a component that accepts no args, then this is a valid invocation.
+type ArglessCurlyComponent = ComponentReturn<{}, any>;
+
+/**
+ * Any value that can be safely set as an HTML attribute on a DOM node.
+ * This includes strings, numbers, booleans and `null`/`undefined`.
+ *
+ * Note that this does not include functions, as writing something like
+ * `onclick={{this.handleClick}}` in a template ultimately relies on
+ * fallback behavior in the VM to set the `onclick` property, and is
+ * better performed using the `{{on}}` modifier.
+ */
+export type AttrValue = string | number | boolean | null | undefined | SafeString;
+
+/**
+ * A value that is invokable like a component in a template. In an
+ * appropriate Glint environment, subclasses of `EmberComponent` and
+ * `GlimmerComponent` are examples of `ComponentLike` values, as are
+ * the values returned from the `{{component}}` helper.
+ *
+ * The `S` signature parameter here is of the same form as the one
+ * accepted by both the Ember and Glimmer `Component` base classes.
+ */
+export type ComponentLike<S = unknown> = Invokable<
+  (
+    ...args: InvokableArgs<ComponentSignatureArgs<S>>
+  ) => ComponentReturn<
+    FlattenBlockParams<ComponentSignatureBlocks<S>>,
+    ComponentSignatureElement<S>
+  >
+>;
+
+/**
+ * A value that is invokable like a helper in a template. Notably,
+ * subclasses of `Helper` and the return value of `helper()` from
+ * `@ember/component/helper` are both `HelperLike` in an appropriate
+ * Glint environment.
+ *
+ * The `S` signature parameter here is of the same form as the one
+ * accepted by `Helper` and `helper`.
+ */
+export type HelperLike<S = unknown> = Invokable<
+  (...args: InvokableArgs<Get<S, 'Args'>>) => Get<S, 'Return', unknown>
+>;
+
+/**
+ * A value that is invokable like a modifier in a template. Notably,
+ * subclasses of `Modifier` and the return value of `modifier()` from
+ * `ember-modifier` are both `ModifierLike` in an appropriate Glint
+ * environment.
+ *
+ * The `S` signature parameter here is of the same form as the ones
+ * accepted by `Modifier` and `modifier`.
+ */
+export type ModifierLike<S = unknown> = Invokable<
+  (element: Get<S, 'Element'>, ...args: InvokableArgs<Get<S, 'Args'>>) => ModifierReturn
+>;
+
+/**
+ * Given a `ComponentLike`, `HelperLike` or `ModifierLike` value
+ * along with a union representing named args that have been
+ * pre-bound, this helper returns the same item back, but with those
+ * named arguments made optional.
+ *
+ * This is typically useful in conjunction with something like the
+ * `{{component}}` helper; for instance, if you wrote this in a
+ * template:
+ *
+ * ```handlebars
+ * {{yield (component MyComponent message="Hello")}}
+ * ```
+ *
+ * Consumers of that yielded value would be able to invoke the
+ * component without having to provide a value for `@message`
+ * themselves. You could represent this in your signature as:
+ *
+ * ```ts
+ * Blocks: {
+ *   default: [WithBoundArgs<typeof MyComponent, 'message'>];
+ * };
+ * ```
+ *
+ * If you had instead just written `default: [typeof MyComponent]`,
+ * consumers would still be obligated to provide a `@message`
+ * arg when invoking the yielded component.
+ */
+export type WithBoundArgs<T extends Invokable<AnyFunction>, BoundArgs extends NamedArgNames<T>> =
+  T extends Invokable<(...args: [...positional: infer P, named: infer N]) => infer R>
+    ? Invokable<
+        (
+          ...args: [
+            ...positional: P,
+            ...named: MaybeNamed<PrebindArgs<UnwrapNamedArgs<NonNullable<N>>, BoundArgs>>,
+          ]
+        ) => R
+      >
+    : never;
+
+/**
+ * Similar to `WithBoundArgs`, this utility type provides a shorthand
+ * for specifying the type of a helper or modifier whose positional
+ * argument(s) have been pre-bound.
+ *
+ * Given the type of the helper or modifier in question and the number
+ * of positional arguments that have been pre-bound, this helper returns
+ * the same item back, but without those leading positional arguments.
+ *
+ * For instance, given a helper `FooHelper` with positional arg types
+ * `[secret: symbol, name: string, age: number]`, then if you wrote
+ * the following in a template:
+ *
+ * ```handlebars
+ * {{yield (helper FooHelper this.secret)}}
+ * ```
+ *
+ * You could represent that in your signature as:
+ *
+ * ```ts
+ * Blocks: {
+ *   default: [WithBoundPositionals<typeof FooHelper, 1>];
+ * };
+ * ```
+ *
+ * Note that you can use `WithBoundPositionals` and `WithBoundArgs`
+ * together if you're pre-binding both positional and named arguments
+ * in the same location.
+ */
+export type WithBoundPositionals<
+  T extends Invokable<AnyFunction> | AnyFunction,
+  Count extends number,
+> =
+  T extends Invokable<(el: infer El, ...args: infer A) => ModifierReturn>
+    ? Invokable<(el: El, ...args: SliceFrom<A, Count>) => ModifierReturn>
+    : T extends Invokable<(...args: infer A) => infer R>
+      ? Invokable<(...args: SliceFrom<A, Count>) => R>
+      : T extends (...args: infer A) => infer R
+        ? Invokable<(...args: SliceFrom<A, Count>) => R>
+        : never;
+
+export {};
+
+}