@discourse/types 2026.1.0-c7e9cdd → 2026.3.0-887c5be4

package/external-types/@glint__ember-tsc/types/-private/dsl/integration-declarations.d.ts

@@ -1,138 +0,0 @@
-declare module '@glint/ember-tsc/types' {
-// This module is responsible for augmenting the upstream definitions of entities that interact
-// with templates to include the information necessary for Glint to typecheck them.
-
-import type { ComponentLike, HelperLike, ModifierLike } from '@glint/template';
-import type {
-  Context,
-  FlattenBlockParams,
-  HasContext,
-  TemplateContext,
-} from '@glint/template/-private/integration';
-import type {
-  ComponentSignatureArgs,
-  ComponentSignatureBlocks,
-  ComponentSignatureElement,
-} from '@glint/template/-private/signature';
-
-//////////////////////////////////////////////////////////////////////
-// Components
-
-import '@ember/component';
-import '@ember/component/template-only';
-import '@glimmer/component';
-
-type ComponentContext<This, S> = TemplateContext<
-  This,
-  ComponentSignatureArgs<S>['Named'],
-  FlattenBlockParams<ComponentSignatureBlocks<S>>,
-  ComponentSignatureElement<S>
->;
-
-declare module '@glimmer/component' {
-  export default interface Component<S> extends InstanceType<ComponentLike<S>> {
-    [Context]: ComponentContext<this, S>;
-  }
-}
-
-import type { InputComponent as ImportedInputComponent } from '../intrinsics/input';
-import type { TextareaComponent as ImportedTextareaComponent } from '../intrinsics/textarea';
-declare module '@ember/component' {
-  export default interface Component<S> extends InstanceType<ComponentLike<S>> {
-    [Context]: ComponentContext<this, S>;
-  }
-  export interface Textarea extends ImportedTextareaComponent {}
-  export interface Input extends ImportedInputComponent {}
-}
-
-interface TemplateOnlyComponentInstance<S> extends InstanceType<ComponentLike<S>> {
-  [Context]: ComponentContext<null, S>;
-}
-
-// As with other abstract constructor types, this allows us to provide a class
-// and therefore have InstanceType work as needed, while forbidding construction
-// by end users.
-type TemplateOnlyConstructor<S> = abstract new () => TemplateOnlyComponentInstance<S>;
-
-declare module '@ember/component/template-only' {
-  export interface TemplateOnlyComponent<S> extends TemplateOnlyConstructor<S> {}
-}
-
-//////////////////////////////////////////////////////////////////////
-// Helpers
-
-import '@ember/component/helper';
-
-declare module '@ember/component/helper' {
-  export default interface Helper<S> extends InstanceType<HelperLike<S>> {}
-}
-
-//////////////////////////////////////////////////////////////////////
-// Modifiers
-
-import 'ember-modifier';
-
-declare module 'ember-modifier' {
-  export default interface ClassBasedModifier<S> extends InstanceType<ModifierLike<S>> {}
-}
-
-//////////////////////////////////////////////////////////////////////
-// Routes and Controllers
-
-import type Controller from '@ember/controller';
-import type Route from '@ember/routing/route';
-
-type ModelForRoute<T extends Route> = Awaited<ReturnType<T['model']>>;
-type ModelField<T> = { model: T };
-
-declare module '@ember/routing/route' {
-  export default interface Route {
-    [Context]: TemplateContext<
-      Controller & ModelField<ModelForRoute<this>>,
-      ModelField<ModelForRoute<this>>,
-      {},
-      null
-    >;
-  }
-}
-
-declare module '@ember/controller' {
-  export default interface Controller {
-    [Context]: TemplateContext<this, ModelField<this['model']>, {}, null>;
-  }
-}
-
-import type { LinkToComponent } from '../intrinsics/link-to';
-declare module '@ember/routing' {
-  export interface LinkTo extends LinkToComponent {}
-}
-
-//////////////////////////////////////////////////////////////////////
-// Rendering Tests
-
-import '@ember/test-helpers';
-
-type TestTemplate<T> = abstract new () => HasContext<TemplateContext<T, {}, {}, void>>;
-
-declare module '@ember/test-helpers' {
-  export function render<T>(template: TestTemplate<T>): Promise<void>;
-}
-
-import '@ember/modifier';
-import type { OnModifier as ImportedOnModifier } from '../intrinsics/on';
-declare module '@ember/modifier' {
-  export interface OnModifier extends ImportedOnModifier {}
-}
-
-import '@ember/helper';
-import type { ConcatHelper as ImportedConcatHelper } from '../intrinsics/concat';
-import type { FnHelper as ImportedFnHelper } from '../intrinsics/fn';
-import type { GetHelper as ImportedGetHelper } from '../intrinsics/get';
-
-declare module '@ember/helper' {
-  export interface ConcatHelper extends ImportedConcatHelper {}
-  export interface FnHelper extends ImportedFnHelper {}
-  export interface GetHelper extends ImportedGetHelper {}
-}
-
-}

package/external-types/@glint__ember-tsc/types/-private/intrinsics/action.d.ts

@@ -1,48 +0,0 @@
-declare module '@glint/ember-tsc/-private/intrinsics/action' {
-import { DirectInvokable, NamedArgs } from '@glint/template/-private/integration';
-
-export type ActionNamedArgs<T> = NamedArgs<{
-  value?: keyof T;
-}>;
-
-export type ActionResult<T, Args extends ActionNamedArgs<T>> = undefined extends Args['value']
-  ? T
-  : Args['value'] extends keyof T
-    ? T[Args['value']]
-    : T;
-
-export type ActionKeyword = DirectInvokable<{
-  <Ret, Args extends ActionNamedArgs<Ret>, Params extends unknown[]>(
-    f: (...rest: Params) => Ret,
-    args?: Args,
-  ): (...rest: Params) => ActionResult<Ret, Args>;
-  <A, Ret, Args extends ActionNamedArgs<Ret>, Params extends unknown[]>(
-    f: (a: A, ...rest: Params) => Ret,
-    a: A,
-    args?: Args,
-  ): (...rest: Params) => ActionResult<Ret, Args>;
-  <A, B, Ret, Args extends ActionNamedArgs<Ret>, Params extends unknown[]>(
-    f: (a: A, b: B, ...rest: Params) => Ret,
-    a: A,
-    b: B,
-    args?: Args,
-  ): (...rest: Params) => ActionResult<Ret, Args>;
-  <A, B, C, Ret, Args extends ActionNamedArgs<Ret>, Params extends unknown[]>(
-    f: (a: A, b: B, c: C, ...rest: Params) => Ret,
-    a: A,
-    b: B,
-    c: C,
-    args?: Args,
-  ): (...rest: Params) => ActionResult<Ret, Args>;
-  <A, B, C, D, Ret, Args extends ActionNamedArgs<Ret>, Params extends unknown[]>(
-    f: (a: A, b: B, c: C, d: D, ...rest: Params) => Ret,
-    a: A,
-    b: B,
-    c: C,
-    d: D,
-    args?: Args,
-  ): (...rest: Params) => ActionResult<Ret, Args>;
-  (action: string, ...rest: unknown[]): (...rest: unknown[]) => unknown;
-}>;
-
-}

package/external-types/@glint__ember-tsc/types/-private/intrinsics/concat.d.ts

@@ -1,9 +0,0 @@
-declare module '@glint/ember-tsc/-private/intrinsics/concat' {
-import { HelperLike } from '@glint/template';
-
-export type ConcatHelper = HelperLike<{
-  Args: { Positional: unknown[] };
-  Return: string;
-}>;
-
-}

package/external-types/@glint__ember-tsc/types/-private/intrinsics/each-in.d.ts

@@ -1,27 +0,0 @@
-declare module '@glint/ember-tsc/-private/intrinsics/each-in' {
-import { ComponentLike } from '@glint/template';
-
-export type EachInKeyword = abstract new <T>() => InstanceType<
-  ComponentLike<{
-    Args: {
-      Positional: [object: T];
-      Named: { key?: string };
-    };
-    Blocks: {
-      default: EachInIteratorPair<T>;
-      else?: [];
-    };
-  }>
->;
-
-type EachInIteratorPair<T> =
-  T extends Iterable<[infer K, infer V]>
-    ? [key: K, value: V]
-    : [key: EachInKey<T>, value: Exclude<T, null | undefined>[EachInKey<T>]];
-
-// `{{each-in}}` internally uses `Object.keys`, so only string keys are included
-// TS, on the other hand, gives a wider result for `keyof` than many users expect
-// for record types: https://github.com/microsoft/TypeScript/issues/29249
-type EachInKey<T> = Extract<keyof Exclude<T, null | undefined>, string>;
-
-}

package/external-types/@glint__ember-tsc/types/-private/intrinsics/each.d.ts

@@ -1,20 +0,0 @@
-declare module '@glint/ember-tsc/-private/intrinsics/each' {
-import EmberArray from '@ember/array';
-import { ComponentLike } from '@glint/template';
-
-type ArrayLike<T> = ReadonlyArray<T> | Iterable<T> | EmberArray<T>;
-
-export type EachKeyword = abstract new <T = any>() => InstanceType<
-  ComponentLike<{
-    Args: {
-      Positional: [items: ArrayLike<T> | null | undefined];
-      Named: { key?: string };
-    };
-    Blocks: {
-      default: [T, number];
-      else: [];
-    };
-  }>
->;
-
-}

package/external-types/@glint__ember-tsc/types/-private/intrinsics/fn.d.ts

@@ -1,47 +0,0 @@
-declare module '@glint/ember-tsc/-private/intrinsics/fn' {
-import { DirectInvokable } from '@glint/template/-private/integration';
-import { Mut } from './mut';
-
-export type FnHelper = DirectInvokable<{
-  <T>(update: Mut<T>): (value: T) => void;
-  <T>(update: Mut<T>, value: T): () => void;
-  <Ret, Args extends unknown[]>(f: (...rest: Args) => Ret): (...rest: Args) => Ret;
-  <A, Ret, Args extends unknown[]>(f: (a: A, ...rest: Args) => Ret, a: A): (...rest: Args) => Ret;
-  <A, B, Ret, Args extends unknown[]>(
-    f: (a: A, b: B, ...rest: Args) => Ret,
-    a: A,
-    b: B,
-  ): (...rest: Args) => Ret;
-  <A, B, C, Ret, Args extends unknown[]>(
-    f: (a: A, b: B, c: C, ...rest: Args) => Ret,
-    a: A,
-    b: B,
-    c: C,
-  ): (...rest: Args) => Ret;
-  <A, B, C, D, Ret, Args extends unknown[]>(
-    f: (a: A, b: B, c: C, d: D, ...rest: Args) => Ret,
-    a: A,
-    b: B,
-    c: C,
-    d: D,
-  ): (...rest: Args) => Ret;
-  <A, B, C, D, E, Ret, Args extends unknown[]>(
-    f: (a: A, b: B, c: C, d: D, e: E, ...rest: Args) => Ret,
-    a: A,
-    b: B,
-    c: C,
-    d: D,
-    e: E,
-  ): (...rest: Args) => Ret;
-  <A, B, C, D, E, G, Ret, Args extends unknown[]>(
-    f: (a: A, b: B, c: C, d: D, e: E, g: G, ...rest: Args) => Ret,
-    a: A,
-    b: B,
-    c: C,
-    d: D,
-    e: E,
-    g: G,
-  ): (...rest: Args) => Ret;
-}>;
-
-}

package/external-types/@glint__ember-tsc/types/-private/intrinsics/get.d.ts

@@ -1,34 +0,0 @@
-declare module '@glint/ember-tsc/-private/intrinsics/get' {
-import { DirectInvokable } from '@glint/template/-private/integration';
-import ObjectProxy from '@ember/object/proxy';
-import '@ember/object/-private/types';
-
-// This hack lets us support both the stable/preview types from `ember-source`
-// and the classic types still live on DefinitelyTyped. If using the DT types,
-// this acts as a declaration merge for a module which is then integrated via
-// the rest of the DT types. If using the stable/preview types, this ends up
-// being a no-op.
-declare const GetSetMarker: unique symbol;
-declare module '@ember/object/-private/types' {
-  interface ComputedPropertyMarker<Get, Set = Get> {
-    [GetSetMarker]: [Get, Set];
-  }
-}
-
-type UnwrapComputedPropertyGetter<T> = T extends { [GetSetMarker]: [infer U, any] } ? U : T;
-
-export type GetHelper = DirectInvokable<{
-  <T, K extends keyof T>(obj: T, key: K): UnwrapComputedPropertyGetter<T[K]>;
-  <T, K extends keyof T>(
-    obj: T | null | undefined,
-    key: K,
-  ): UnwrapComputedPropertyGetter<T[K]> | undefined;
-  <T extends object, K extends keyof T>(
-    obj: ObjectProxy<T> | null | undefined,
-    key: K,
-  ): UnwrapComputedPropertyGetter<T[K]> | undefined;
-  (obj: null | undefined, key: string): undefined;
-  (obj: unknown, key: string): unknown;
-}>;
-
-}

package/external-types/@glint__ember-tsc/types/-private/intrinsics/input.d.ts

@@ -1,24 +0,0 @@
-import { ComponentLike } from '@glint/template';
-
-export interface CheckboxInputArgs {
-  type: 'checkbox';
-  checked?: boolean | undefined;
-}
-
-export interface TextInputArgs {
-  type?: string | undefined;
-  value?: string | null | undefined;
-  enter?: ((value: string, event: KeyboardEvent) => void) | undefined;
-  'insert-newline'?: ((value: string, event: KeyboardEvent) => void) | undefined;
-  'escape-press'?: ((value: string, event: KeyboardEvent) => void) | undefined;
-  'focus-in'?: ((value: string, event: FocusEvent) => void) | undefined;
-  'focus-out'?: ((value: string, event: FocusEvent) => void) | undefined;
-  'key-down'?: ((value: string, event: KeyboardEvent) => void) | undefined;
-  'key-press'?: ((value: string, event: KeyboardEvent) => void) | undefined;
-  'key-up'?: ((value: string, event: KeyboardEvent) => void) | undefined;
-}
-
-export type InputComponent = ComponentLike<{
-  Args: { Named: CheckboxInputArgs | TextInputArgs };
-  Element: HTMLInputElement;
-}>;

package/external-types/@glint__ember-tsc/types/-private/intrinsics/link-to.d.ts

@@ -1,31 +0,0 @@
-import { ComponentLike } from '@glint/template';
-import { ComponentReturn, DirectInvokable, NamedArgs } from '@glint/template/-private/integration';
-
-type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> &
-  {
-    [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
-  }[Keys];
-
-type LinkToArgs = RequireAtLeastOne<
-  {
-    route?: string;
-    model?: unknown;
-    models?: unknown[];
-    query?: Record<string, unknown>;
-    disabled?: boolean;
-    activeClass?: string;
-    'current-when'?: string | boolean;
-    preventDefault?: boolean;
-    replace?: boolean;
-    tagName?: string;
-  },
-  'route' | 'model' | 'models' | 'query'
->;
-
-type LinkToReturn = ComponentReturn<{ default: [] }, HTMLAnchorElement>;
-
-export type LinkToComponent = ComponentLike<{
-  Args: LinkToArgs;
-  Blocks: { default: [] };
-  Element: HTMLAnchorElement;
-}>;

package/external-types/@glint__ember-tsc/types/-private/intrinsics/log.d.ts

@@ -1,9 +0,0 @@
-declare module '@glint/ember-tsc/-private/intrinsics/log' {
-import { HelperLike } from '@glint/template';
-
-export type LogHelper = HelperLike<{
-  Args: { Positional: unknown[] };
-  Return: void;
-}>;
-
-}

package/external-types/@glint__ember-tsc/types/-private/intrinsics/mount.d.ts

@@ -1,12 +0,0 @@
-declare module '@glint/ember-tsc/-private/intrinsics/mount' {
-import { HelperLike } from '@glint/template';
-
-export type MountKeyword = HelperLike<{
-  Args: {
-    Positional: [engine: string];
-    Named: { model?: unknown };
-  };
-  Return: void;
-}>;
-
-}

package/external-types/@glint__ember-tsc/types/-private/intrinsics/mut.d.ts

@@ -1,17 +0,0 @@
-declare module '@glint/ember-tsc/-private/intrinsics/mut' {
-import { HelperLike } from '@glint/template';
-
-declare const Mut: unique symbol;
-
-export type Mut<T> = { [Mut]: (value: T) => void };
-
-export type MutKeyword = abstract new <T>() => InstanceType<
-  HelperLike<{
-    Args: {
-      Positional: [value: T];
-    };
-    Return: Mut<T>;
-  }>
->;
-
-}

package/external-types/@glint__ember-tsc/types/-private/intrinsics/on.d.ts

@@ -1,24 +0,0 @@
-declare module '@glint/ember-tsc/-private/intrinsics/on' {
-import { ModifierLike } from '@glint/template';
-
-export interface OnModifierArgs {
-  capture?: boolean;
-  once?: boolean;
-  passive?: boolean;
-}
-
-export type EventForName<Name extends string> = Name extends keyof HTMLElementEventMap
-  ? HTMLElementEventMap[Name]
-  : Event;
-
-export type OnModifier = abstract new <Name extends string>() => InstanceType<
-  ModifierLike<{
-    Element: Element;
-    Args: {
-      Named: OnModifierArgs;
-      Positional: [name: Name, callback: (event: EventForName<Name>) => void];
-    };
-  }>
->;
-
-}

package/external-types/@glint__ember-tsc/types/-private/intrinsics/outlet.d.ts

@@ -1,11 +0,0 @@
-declare module '@glint/ember-tsc/-private/intrinsics/outlet' {
-import { HelperLike } from '@glint/template';
-
-export type OutletKeyword = HelperLike<{
-  Args: {
-    Positional: [name?: string];
-  };
-  Return: void;
-}>;
-
-}

package/external-types/@glint__ember-tsc/types/-private/intrinsics/textarea.d.ts

@@ -1,16 +0,0 @@
-import { ComponentLike } from '@glint/template';
-
-export interface TextareaArgs {
-  value?: string | null | undefined;
-  enter?: ((value: string, event: KeyboardEvent) => void) | undefined;
-  'insert-newline'?: ((value: string, event: KeyboardEvent) => void) | undefined;
-  'escape-press'?: ((value: string, event: KeyboardEvent) => void) | undefined;
-  'focus-in'?: ((value: string, event: FocusEvent) => void) | undefined;
-  'focus-out'?: ((value: string, event: FocusEvent) => void) | undefined;
-  'key-press'?: ((value: string, event: KeyboardEvent) => void) | undefined;
-}
-
-export type TextareaComponent = ComponentLike<{
-  Args: TextareaArgs;
-  Element: HTMLTextAreaElement;
-}>;

package/external-types/@glint__ember-tsc/types/-private/intrinsics/unbound.d.ts

@@ -1,13 +0,0 @@
-declare module '@glint/ember-tsc/-private/intrinsics/unbound' {
-import { HelperLike } from '@glint/template';
-
-export type UnboundKeyword = abstract new <T>() => InstanceType<
-  HelperLike<{
-    Args: {
-      Positional: [value: T];
-    };
-    Return: T;
-  }>
->;
-
-}

package/external-types/@glint__ember-tsc/types/-private/intrinsics/unique-id.d.ts

@@ -1,8 +0,0 @@
-declare module '@glint/ember-tsc/-private/intrinsics/unique-id' {
-import { HelperLike } from '@glint/template';
-
-export type UniqueIdHelper = HelperLike<{
-  Return: string;
-}>;
-
-}

package/external-types/@glint__ember-tsc/types/globals/index.d.ts

@@ -1,6 +0,0 @@
-declare module '@glint/ember-tsc/globals' {
-export default interface Globals {
-  // used to hang any macros off of that are provided by config.additionalGlobals
-}
-
-}

package/external-types/@glint__ember-tsc/types/silent-error.d.ts

@@ -1,4 +0,0 @@
-declare module 'silent-error' {
-  class SilentError extends Error {}
-  export default SilentError;
-}