@discourse/types 0.0.2 → 2026.1.0-2709d36

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

@@ -1,178 +0,0 @@
-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

@@ -1,144 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,187 +0,0 @@
-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 {};
-
-}