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

package/external-types/discourse-i18n/index.d.ts

@@ -0,0 +1,68 @@
+declare module 'discourse-i18n' {
+	export class I18n {
+	    defaultLocale: string;
+	    locale: any;
+	    fallbackLocale: any;
+	    translations: any;
+	    extras: {};
+	    noFallbacks: boolean;
+	    testing: boolean;
+	    verbose: boolean;
+	    verboseIndices: Map<any, any>;
+	    pluralizationRules: typeof Cardinals;
+	    translate: (scope: any, options: any) => any;
+	    t: (scope: any, options: any) => any;
+	    currentLocale(): any;
+	    get currentBcp47Locale(): any;
+	    get pluralizationNormalizedLocale(): any;
+	    enableVerboseLocalization(): void;
+	    enableVerboseLocalizationSession(): string;
+	    disableVerboseLocalizationSession(): string;
+	    _translate(scope: any, options: any): any;
+	    toNumber(number: any, options: any): string;
+	    toHumanSize(number: any, options: any): any;
+	    pluralize(translation: any, scope: any, options: any): any;
+	    pluralizer(locale: any): any;
+	    listJoiner(listOfStrings: any, delimiter: any): any;
+	    interpolate(message: any, options: any, scope: any): any;
+	    /**
+	     * Extract the placeholders from the translated string before interpolation.
+	     *
+	     * @param {String} message The translated string.
+	     *
+	     * @returns {Map<String, Array<String>>} A Map keyed by the placeholder name, with the value set to
+	     * how the placeholder appears in the string. If it appears multiple times, each instance will be
+	     * recorded (eg, "foo" => ["%{foo}", "{{foo}}"]).
+	     */
+	    findPlaceholders(message: string): Map<string, Array<string>>;
+	    findTranslation(scope: any, options: any): any;
+	    /**
+	     * Given the current options (and if fallback is enabled), find the translation
+	     * for the given scope.
+	     *
+	     * @param {String} scope The reference for the translatable string.
+	     * @param {Object} options Custom options for this string.
+	     *
+	     * @returns {Array<String>|String} The translated string, or array of strings for pluralizable translations.
+	     */
+	    findTranslationWithFallback(scope: string, options: any): Array<string> | string;
+	    findAndTranslateValidNode(keys: any, translation: any): any;
+	    lookup(scope: any, options?: {}): any;
+	    missingTranslation(scope: any, key: any, options: any): string;
+	    prepareOptions(...args: any[]): {};
+	    isValidNode(obj: any, node: any): boolean;
+	    messageFormat(key: any, options: any): any;
+	    _verboseTranslate(scope: any, options: any): string;
+	    loadData(): void;
+	    _mfMessages: Messages;
+	    #private;
+	}
+	export class I18nMissingInterpolationArgument extends Error {
+	    constructor(message: any);
+	}
+	export default I18nInstance;
+	export function i18n(scope: any, options: any): any;
+	import * as Cardinals from 'make-plural/cardinals';
+	import Messages from '@messageformat/runtime/messages'; const I18nInstance: I18n;
+	//# sourceMappingURL=index.d.ts.map
+}

package/external-types/discourse-i18n/package.json

@@ -8,6 +8,7 @@
   "keywords": [
     "ember-addon"
   ],
+  "types": "index.d.ts",
   "exports": {
     ".": {
       "types": "./src/index.d.ts",
@@ -25,7 +26,7 @@
     "make-plural": "^8.1.0"
   },
   "engines": {
-    "node": ">= 18",
+    "node": ">= 20",
     "npm": "please-use-pnpm",
     "yarn": "please-use-pnpm",
     "pnpm": "^10"
@@ -38,5 +39,6 @@
     "type": "addon",
     "main": "addon-main.cjs",
     "app-js": {}
-  }
-}
+  },
+  "__types": "src/index.d.ts"
+}

package/external-types/ember-compat__tracked-built-ins/index.d.ts

@@ -0,0 +1,174 @@
+declare module '@ember-compat/tracked-built-ins/-private/map' {
+	 class TrackedMap<K = unknown, V = unknown> implements Map<K, V> {
+	    private collection;
+	    private storages;
+	    private vals;
+	    private readStorageFor;
+	    private dirtyStorageFor;
+	    constructor();
+	    constructor(entries: readonly (readonly [K, V])[] | null);
+	    constructor(iterable: Iterable<readonly [K, V]>);
+	    // **** KEY GETTERS ****
+	    get(key: K): V | undefined;
+	    has(key: K): boolean;
+	    // **** ALL GETTERS ****
+	    entries(): IterableIterator<[K, V]>;
+	    keys(): IterableIterator<K>;
+	    values(): IterableIterator<V>;
+	    forEach(fn: (value: V, key: K, map: Map<K, V>) => void): void;
+	    get size(): number;
+	    [Symbol.iterator](): IterableIterator<[K, V]>;
+	    get [Symbol.toStringTag](): string;
+	    // **** KEY SETTERS ****
+	    set(key: K, value: V): this;
+	    delete(key: K): boolean;
+	    // **** ALL SETTERS ****
+	    clear(): void;
+	} class TrackedWeakMap<K extends object = object, V = unknown> implements WeakMap<K, V> {
+	    private storages;
+	    private vals;
+	    private readStorageFor;
+	    private dirtyStorageFor;
+	    constructor();
+	    constructor(iterable: Iterable<readonly [K, V]>);
+	    constructor(entries: readonly [K, V][] | null);
+	    get(key: K): V | undefined;
+	    has(key: K): boolean;
+	    set(key: K, value: V): this;
+	    delete(key: K): boolean;
+	    get [Symbol.toStringTag](): string;
+	}
+	export { TrackedMap, TrackedWeakMap };
+
+}
+declare module '@ember-compat/tracked-built-ins/-private/set' {
+	 class TrackedSet<T = unknown> implements Set<T> {
+	    private collection;
+	    private storages;
+	    private vals;
+	    private storageFor;
+	    private dirtyStorageFor;
+	    constructor();
+	    constructor(values: readonly T[] | null);
+	    constructor(iterable: Iterable<T>);
+	    // **** KEY GETTERS ****
+	    has(value: T): boolean;
+	    // **** ALL GETTERS ****
+	    entries(): IterableIterator<[T, T]>;
+	    keys(): IterableIterator<T>;
+	    values(): IterableIterator<T>;
+	    forEach(fn: (value1: T, value2: T, set: Set<T>) => void): void;
+	    get size(): number;
+	    [Symbol.iterator](): IterableIterator<T>;
+	    get [Symbol.toStringTag](): string;
+	    // **** KEY SETTERS ****
+	    add(value: T): this;
+	    delete(value: T): boolean;
+	    // **** ALL SETTERS ****
+	    clear(): void;
+	} class TrackedWeakSet<T extends object = object> implements WeakSet<T> {
+	    private storages;
+	    private vals;
+	    private storageFor;
+	    private dirtyStorageFor;
+	    constructor(values?: readonly T[] | null);
+	    has(value: T): boolean;
+	    add(value: T): this;
+	    delete(value: T): boolean;
+	    get [Symbol.toStringTag](): string;
+	}
+	export { TrackedSet, TrackedWeakSet };
+
+}
+declare module '@ember-compat/tracked-built-ins/-private/array' {
+	 class TrackedArray<T = unknown> {
+	    #private;
+	    /**
+	     * Creates an array from an iterable object.
+	     * @param iterable An iterable object to convert to an array.
+	     */
+	    /**
+	     * Creates an array from an iterable object.
+	     * @param iterable An iterable object to convert to an array.
+	     */
+	    static from<T>(iterable: Iterable<T> | ArrayLike<T>): TrackedArray<T>;
+	    /**
+	     * Creates an array from an iterable object.
+	     * @param iterable An iterable object to convert to an array.
+	     * @param mapfn A mapping function to call on every element of the array.
+	     * @param thisArg Value of 'this' used to invoke the mapfn.
+	     */
+	    /**
+	     * Creates an array from an iterable object.
+	     * @param iterable An iterable object to convert to an array.
+	     * @param mapfn A mapping function to call on every element of the array.
+	     * @param thisArg Value of 'this' used to invoke the mapfn.
+	     */
+	    static from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: unknown): TrackedArray<U>;
+	    static of<T>(...arr: T[]): TrackedArray<T>;
+	    constructor(arr?: T[]);
+	}
+	interface TrackedArray<T = unknown> extends Array<T> {
+	}
+	export { TrackedArray as default };
+	//# sourceMappingURL=-private/array.d.ts.map
+}
+declare module '@ember-compat/tracked-built-ins/-private/decorator' {
+	import { TrackedMap, TrackedWeakMap } from '@ember-compat/tracked-built-ins/-private/map';
+	import { TrackedSet, TrackedWeakSet } from '@ember-compat/tracked-built-ins/-private/set';
+	import TrackedArray from '@ember-compat/tracked-built-ins/-private/array'; function tracked<T>(obj: T[] | typeof Array): TrackedArray<T>; function tracked<T>(obj: Set<T> | typeof Set): TrackedSet<T>; function tracked<T, U>(obj: Map<T, U> | typeof Map): TrackedMap<T, U>; function tracked<T extends object>(obj: WeakSet<T> | typeof WeakSet): TrackedWeakSet<T>; function tracked<T extends object, U>(obj: WeakMap<T, U> | typeof WeakMap): TrackedWeakMap<T, U>; function tracked<T extends object>(obj: T | typeof Object): T; function tracked(obj: object, key: string | symbol, desc?: PropertyDescriptor): void;
+	export { tracked as default };
+
+}
+declare module '@ember-compat/tracked-built-ins/-private/object' {
+	interface TrackedObjectClass {
+	    /**
+	     * Returns an object created by key-value entries for properties and methods
+	     * @param entries An iterable object that contains key-value entries for properties and methods.
+	     *
+	     * Note: interface matches the built-in types, which use `any`, for maximum compat.
+	     */
+	    fromEntries<T = any>(entries: Iterable<readonly [PropertyKey, T]>): {
+	        [k: string]: T;
+	    };
+	    /**
+	     * Returns an object created by key-value entries for properties and methods
+	     * @param entries An iterable object that contains key-value entries for properties and methods.
+	     *
+	     * Note: interface matches the built-in types, which use `any`, for maximum compat.
+	     */
+	    fromEntries<T>(entries: Iterable<readonly [any, T][]>): Record<string, T>;
+	    new <T extends Record<PropertyKey, unknown> = Record<PropertyKey, unknown>>(obj?: T): T;
+	} const TrackedObject: TrackedObjectClass;
+	type TrackedObject<T = {}> = T;
+	export { TrackedObject as default };
+
+}
+declare module '@ember-compat/tracked-built-ins' {
+	export { default as tracked } from '@ember-compat/tracked-built-ins/-private/decorator';
+	export { default as TrackedArray } from '@ember-compat/tracked-built-ins/-private/array';
+	export { default as TrackedObject } from '@ember-compat/tracked-built-ins/-private/object';
+	export { TrackedMap, TrackedWeakMap } from '@ember-compat/tracked-built-ins/-private/map';
+	export { TrackedSet, TrackedWeakSet } from '@ember-compat/tracked-built-ins/-private/set';
+
+}
+declare module '@ember-compat/tracked-built-ins/-private/property-storage-map' {
+	 class PropertyStorageMap {
+	    #private;
+	    constructor(object: object);
+	    consume(key: string | symbol): void;
+	    update(key: string | symbol): void;
+	}
+	export { PropertyStorageMap };
+
+}
+declare module '@ember-compat/tracked-built-ins/-private/utils' {
+	 function isAccessorDescriptor(descriptor: PropertyDescriptor): boolean; function cloneObjectWithAccessors<T extends Record<PropertyKey, unknown> = Record<PropertyKey, unknown>>(obj: T): T;
+	export { isAccessorDescriptor, cloneObjectWithAccessors };
+
+}
+declare module '@ember-compat/tracked-built-ins/-private/validator-versions' {
+	 const dirtyProperty: (object: object, property: PropertyKey) => void, consumeProperty: (object: object, property: PropertyKey) => void;
+	export { dirtyProperty, consumeProperty };
+
+}

package/external-types/{@ember-compat__tracked-built-ins → ember-compat__tracked-built-ins}/package.json

@@ -18,16 +18,6 @@
     "./test-support": "./dist/test-support/index.js",
     "./addon-main.js": "./addon-main.js"
   },
-  "typesVersions": {
-    "*": {
-      ".": [
-        "./dist/index.d.ts"
-      ],
-      "*": [
-        "./dist/*"
-      ]
-    }
-  },
   "files": [
     "addon-main.js",
     "dist"
@@ -89,5 +79,16 @@
     "externals": [
       "@glimmer/validator"
     ]
-  }
-}
+  },
+  "__typesVersions": {
+    "*": {
+      ".": [
+        "./dist/index.d.ts"
+      ],
+      "*": [
+        "./dist/*"
+      ]
+    }
+  },
+  "types": "index.d.ts"
+}

package/external-types/ember-modifier/index.d.ts

@@ -0,0 +1,327 @@
+declare module 'ember-modifier/-private/signature' {
+	/** @private */
+	export type ElementFor<S> = 'Element' extends keyof S ? S['Element'] extends Element ? S['Element'] : Element : Element;
+	type DefaultPositional = [];
+	type GetOrElse<T, K, Fallback> = K extends keyof T ? T[K] : Fallback;
+	/**
+	 * A convenience type utility, primarily for working with args in the `modify`
+	 * hook on class-based modifiers. Given a signature `S` it will return the
+	 * correct positional args for that signature. For example:
+	 *
+	 * ```ts
+	 * import Modifier, { NamedArgs } from 'ember-modifier';
+	 *
+	 * interface OnClickOutsideSig {
+	 *   Args: {
+	 *     Positional: [handler: () => void];
+	 *   };
+	 * }
+	 *
+	 * export default class Example extends Modifier<OnClickOutsideSig> {
+	 *   element = null;
+	 *
+	 *   modify(el: Element, _: [handler]: PositionalArgs<OnClickOutsideSig>) {
+	 *     if (!this.element) {
+	 *       this.element = el;
+	 *     }
+	 *
+	 *     this.clearHandler();
+	 *     this.handler = handler;
+	 *
+	 *     document.addEventListener('click', this.onClickOutside);
+	 *
+	 *     // Normally this would be better done in `constructor` or similar.
+	 *     unregisterDestructor(this, this.clearHandler);
+	 *     registerDestructor(this, this.clearHandler);
+	 *   }
+	 *
+	 *   onClickOutside = (event: MouseEvent) => {
+	 *     // SAFETY: a "standard" safe cast for event.target here
+	 *     if (!this.element.contains(event.target as Node)) {
+	 *       this.handler();
+	 *     }
+	 *   }
+	 *
+	 *   clearHandler = () => {
+	 *     document.removeEventListener('click', this.onClickOutside);
+	 *   }
+	 * }
+	 * ```
+	 *
+	 * (This example does not need to be, and should not be, class-based, but is
+	 * useful to illustrate how to use the type utility.)
+	 */
+	export type PositionalArgs<S> = 'Args' extends keyof S ? GetOrElse<S['Args'], 'Positional', DefaultPositional> : DefaultPositional; const Empty: unique symbol;
+	export interface EmptyObject {
+	    [Empty]?: true;
+	}
+	type DefaultNamed = EmptyObject;
+	/**
+	 * A convenience type utility, primarily for working with args in the `modify`
+	 * hook on class-based modifiers. Given a signature `S` it will return the
+	 * correct named args for that signature:
+	 *
+	 * ```ts
+	 * import Modifier, { NamedArgs } from 'ember-modifier';
+	 *
+	 * interface PlaySig {
+	 *   Element: HTMLElement;
+	 *   Args: {
+	 *     Named: {
+	 *       when: string;
+	 *     };
+	 *   };
+	 * }
+	 *
+	 * export default class Example extends Modifier<Sig> {
+	 *   modify(el: HTMLMediaElement, _: [], { when: shouldPlay }: NamedArgs<PlaySig>) {
+	 *     if (shouldPlay) {
+	 *       el.play();
+	 *     } else {
+	 *       el.pause();
+	 *     }
+	 *   }
+	 * }
+	 * ```
+	 *
+	 * (This example does not need to be, and should not be, class-based, but is
+	 * useful to illustrate the point.)
+	 */
+	export type NamedArgs<S> = 'Args' extends keyof S ? GetOrElse<S['Args'], 'Named', DefaultNamed> : DefaultNamed;
+	/** @private */
+	export interface DefaultSignature {
+	    Element: Element;
+	}
+	/**
+	 * A convenience type utility, primarily for working with args in the `modify`
+	 * hook on class-based modifiers. Given a signature `S` it will return the
+	 * correct positional args for that signature, to be used with
+	 */
+	export interface ArgsFor<S> {
+	    named: NamedArgs<S>;
+	    positional: PositionalArgs<S>;
+	}
+	export {};
+	//# sourceMappingURL=signature.d.ts.map
+}
+declare module 'ember-modifier/-private/opaque' {
+	 const Brand: unique symbol; class _Opaque<T> {
+	    private readonly [Brand];
+	}
+	interface Opaque<T> extends _Opaque<T> {
+	}
+	export default Opaque;
+	//# sourceMappingURL=opaque.d.ts.map
+}
+declare module 'ember-modifier/-private/class-based/modifier' {
+	import type Owner from '@ember/owner';
+	import type { ElementFor, ArgsFor, DefaultSignature, PositionalArgs, NamedArgs } from 'ember-modifier/-private/signature';
+	import type Opaque from 'ember-modifier/-private/opaque';
+	export default interface ClassBasedModifier<S = DefaultSignature> extends Opaque<S> {
+	}
+	/**
+	 * A base class for modifiers which need more capabilities than function-based
+	 * modifiers. Useful if, for example:
+	 *
+	 * 1. You need to inject services and access them
+	 * 2. You need fine-grained control of updates, either for performance or
+	 *    convenience reasons, and don't want to teardown the state of your modifier
+	 *    every time only to set it up again.
+	 * 3. You need to store some local state within your modifier.
+	 *
+	 * The lifecycle hooks of class modifiers are tracked. When they run, they any
+	 * values they access will be added to the modifier, and the modifier will
+	 * update if any of those values change.
+	 */
+	export default class ClassBasedModifier<S = DefaultSignature> {
+	    /**
+	     *
+	     * @param owner An instance of an Owner (for service injection etc.).
+	     * @param args The positional and named arguments passed to the modifier.
+	     */
+	    constructor(owner: Owner, args: ArgsFor<S>);
+	    /**
+	     * Called when the modifier is installed and any time any tracked state used
+	     * in the modifier changes.
+	     *
+	     * If you need to do first-time-only setup, create a class field representing
+	     * the initialization state and check it when running the hook. That is also
+	     * where and when you should use `registerDestructor` for any teardown you
+	     * need to do. For example:
+	     *
+	     * ```js
+	     * function disconnect(instance) {
+	     *  instance.observer?.disconnect();
+	     * }
+	     *
+	     * class IntersectionObserver extends Modifier {
+	     *   observer;
+	     *
+	     *   constructor(owner, args) {
+	     *     super(owner, args);
+	     *     registerDestructor(this, disconnect);
+	     *   }
+	     *
+	     *   modify(element, callback, options) {
+	     *     disconnect(this);
+	     *
+	     *     this.observer = new IntersectionObserver(callback, options);
+	     *     this.observer.observe(element);
+	     *   }
+	     * }
+	     * ```
+	     *
+	     * @param element The element to which the modifier is applied.
+	     * @param positional The positional arguments to the modifier.
+	     * @param named The named arguments to the modifier.
+	     */
+	    modify(element: ElementFor<S>, positional: PositionalArgs<S>, named: NamedArgs<S>): void;
+	}
+	//# sourceMappingURL=modifier.d.ts.map
+}
+declare module 'ember-modifier/-private/function-based/modifier' {
+	import type { ElementFor, EmptyObject, NamedArgs, PositionalArgs } from 'ember-modifier/-private/signature';
+	import type Modifier from 'ember-modifier/-private/class-based/modifier';
+	export abstract class FunctionBasedModifierInstance<S> extends Modifier<S> {
+	    protected abstract __concrete__: never;
+	}
+	export type FunctionBasedModifier<S> = abstract new () => FunctionBasedModifierInstance<S>;
+	/**
+	 * The (optional) return type for a modifier which needs to perform some kind of
+	 * cleanup or teardown -- for example, removing an event listener from an
+	 * element besides the one passed into the modifier.
+	 */
+	export type Teardown = () => unknown;
+	/**
+	 * An API for writing simple modifiers.
+	 *
+	 * This function runs the first time when the element the modifier was applied
+	 * to is inserted into the DOM, and it *autotracks* while running. Any values
+	 * that it accesses will be tracked, including any of its arguments that it
+	 * accesses, and if any of them changes, the function will run again.
+	 *
+	 * **Note:** this will *not* automatically rerun because an argument changes. It
+	 * will only rerun if it is *using* that argument (the same as with auto-tracked
+	 * state in general).
+	 *
+	 * The modifier can also optionally return a *destructor*. The destructor
+	 * function will be run just before the next update, and when the element is
+	 * being removed entirely. It should generally clean up the changes that the
+	 * modifier made in the first place.
+	 *
+	 * @param fn The function which defines the modifier.
+	 */
+	export default function modifier<E extends Element, P extends unknown[], N = EmptyObject>(fn: (element: E, positional: P, named: N) => void | Teardown): FunctionBasedModifier<{
+	    Args: {
+	        Positional: P;
+	        Named: N;
+	    };
+	    Element: E;
+	}>;
+	/**
+	 * An API for writing simple modifiers.
+	 *
+	 * This function runs the first time when the element the modifier was applied
+	 * to is inserted into the DOM, and it *autotracks* while running. Any values
+	 * that it accesses will be tracked, including any of its arguments that it
+	 * accesses, and if any of them changes, the function will run again.
+	 *
+	 * **Note:** this will *not* automatically rerun because an argument changes. It
+	 * will only rerun if it is *using* that argument (the same as with auto-tracked
+	 * state in general).
+	 *
+	 * The modifier can also optionally return a *destructor*. The destructor
+	 * function will be run just before the next update, and when the element is
+	 * being removed entirely. It should generally clean up the changes that the
+	 * modifier made in the first place.
+	 *
+	 * @param fn The function which defines the modifier.
+	 */
+	export default function modifier<S>(fn: (element: ElementFor<S>, positional: PositionalArgs<S>, named: NamedArgs<S>) => void | Teardown): FunctionBasedModifier<{
+	    Element: ElementFor<S>;
+	    Args: {
+	        Named: NamedArgs<S>;
+	        Positional: PositionalArgs<S>;
+	    };
+	}>;
+	/**
+	 * @internal
+	 */
+	export type FunctionBasedModifierDefinition<S> = (element: ElementFor<S>, positional: PositionalArgs<S>, named: NamedArgs<S>) => void | Teardown;
+	//# sourceMappingURL=modifier.d.ts.map
+}
+declare module 'ember-modifier' {
+	export { default } from 'declarations/-private/class-based/modifier.ts';
+	export { default as modifier } from 'declarations/-private/function-based/modifier.ts';
+	export type { FunctionBasedModifier } from 'declarations/-private/function-based/modifier.ts';
+	export type { ArgsFor, NamedArgs, PositionalArgs, } from 'declarations/-private/signature.ts';
+	//# sourceMappingURL=index.d.ts.map
+}
+declare module 'ember-modifier/-private/class-based/modifier-manager' {
+	import type Owner from '@ember/owner';
+	import type ClassBasedModifier from 'ember-modifier/-private/class-based/modifier';
+	import type { ArgsFor, ElementFor } from 'ember-modifier/-private/signature';
+	/**
+	 * The state bucket used throughout the life-cycle of the modifier. Basically a
+	 * state *machine*, where the framework calls us with the version we hand back
+	 * to it at each phase. The two states are the two `extends` versions of this
+	 * below.
+	 *
+	 * @internal
+	 */
+	interface State<S> {
+	    instance: ClassBasedModifier<S>;
+	}
+	/**
+	 * The `State` after calling `createModifier`, and therefore the state available
+	 * at the start of `InstallModifier`.
+	 * @internal
+	 */
+	interface CreatedState<S> extends State<S> {
+	    element: null;
+	}
+	/**
+	 * The `State` after calling `installModifier`, and therefore the state
+	 * available in all `updateModifier` calls and in `destroyModifier`.
+	 * @internal
+	 */
+	interface InstalledState<S> extends State<S> {
+	    element: ElementFor<S>;
+	}
+	export default class ClassBasedModifierManager<S> {
+	    private owner;
+	    capabilities: unknown;
+	    constructor(owner: Owner);
+	    createModifier(modifierClass: typeof ClassBasedModifier, args: ArgsFor<S>): CreatedState<S>;
+	    installModifier(createdState: CreatedState<S>, element: ElementFor<S>, args: ArgsFor<S>): void;
+	    updateModifier(state: InstalledState<S>, args: ArgsFor<S>): void;
+	    destroyModifier({ instance }: InstalledState<S>): void;
+	}
+	export {};
+	//# sourceMappingURL=modifier-manager.d.ts.map
+}
+declare module 'ember-modifier/-private/function-based/modifier-manager' {
+	import type { FunctionBasedModifierDefinition, Teardown } from 'ember-modifier/-private/function-based/modifier';
+	import type { ArgsFor, ElementFor } from 'ember-modifier/-private/signature';
+	interface State<S> {
+	    instance: FunctionBasedModifierDefinition<S>;
+	}
+	interface CreatedState<S> extends State<S> {
+	    element: null;
+	}
+	interface InstalledState<S> extends State<S> {
+	    element: ElementFor<S>;
+	    teardown?: Teardown;
+	}
+	export default class FunctionBasedModifierManager<S> {
+	    capabilities: unknown;
+	    createModifier(instance: FunctionBasedModifierDefinition<S>): CreatedState<S>;
+	    installModifier(createdState: CreatedState<S>, element: ElementFor<S>, args: ArgsFor<S>): void;
+	    updateModifier(state: InstalledState<S>, args: ArgsFor<S>): void;
+	    destroyModifier(state: InstalledState<S>): void;
+	    getDebugName(state: InstalledState<S>): string;
+	    getDebugInstance(state: InstalledState<S>): InstalledState<S>;
+	}
+	export {};
+	//# sourceMappingURL=modifier-manager.d.ts.map
+}