@discourse/types 0.0.1 → 2026.1.0-a5a0839

package/external-types/ember-source/types/stable/ember/index.d.ts

@@ -0,0 +1,370 @@
+declare module 'ember' {
+    /**
+    @module ember
+    */
+    import * as utils from "@ember/-internals/utils";
+    import { Registry as InternalRegistry, Container as InternalContainer } from "@ember/-internals/container";
+    import * as instrumentation from "@ember/instrumentation";
+    import * as metal from "@ember/-internals/metal";
+    import { isEnabled } from "@ember/canary-features";
+    import * as EmberDebug from "@ember/debug";
+    import Backburner from "backburner.js";
+    import EmberController, { inject as injectController, ControllerMixin as EmberControllerMixin } from "@ember/controller";
+    import EmberService from "@ember/service";
+    import EmberObject, { action, observer as emberObserver } from "@ember/object";
+    import { dependentKeyCompat } from "@ember/object/compat";
+    import EmberComputedProperty from "@ember/object/computed";
+    import { RSVP as _RSVP, Comparable as InternalComparable, ActionHandler as InternalActionHandler } from "@ember/-internals/runtime";
+    import { componentCapabilities, modifierCapabilities, setComponentManager, template, isSerializationFirstNode, type TemplatesRegistry } from "@ember/-internals/glimmer";
+    import * as views from "@ember/-internals/views";
+    import EmberContainerDebugAdapter from "@ember/debug/container-debug-adapter";
+    import EmberDataAdapter from "@ember/debug/data-adapter";
+    import { run as emberRun } from "@ember/runloop";
+    import EmberArray, { NativeArray as EmberNativeArray, isArray as emberIsArray, makeArray as emberMakeArray } from "@ember/array";
+    import EmberMutableArray from "@ember/array/mutable";
+    import EmberArrayProxy from "@ember/array/proxy";
+    import EmberApplication, { onLoad as applicationOnLoad, runLoadHooks as applicationRunLoadHooks } from "@ember/application";
+    import EmberApplicationInstance from "@ember/application/instance";
+    import EmberNamespace from "@ember/application/namespace";
+    import EmberComponent, { Input as EmberInput } from "@ember/component";
+    import EmberHelper from "@ember/component/helper";
+    import EmberEngine from "@ember/engine";
+    import EmberEngineInstance from "@ember/engine/instance";
+    import EmberEnumerable from "@ember/enumerable";
+    import EmberMutableEnumerable from "@ember/enumerable/mutable";
+    import EmberCoreObject from "@ember/object/core";
+    import EmberEvented from "@ember/object/evented";
+    import EmberMixin, { mixin as emberMixin } from "@ember/object/mixin";
+    import EmberObservable from "@ember/object/observable";
+    import EmberObjectProxy from "@ember/object/proxy";
+    import EmberPromiseProxyMixin from "@ember/object/promise-proxy-mixin";
+    import EmberHashLocation from "@ember/routing/hash-location";
+    import EmberHistoryLocation from "@ember/routing/history-location";
+    import EmberNoneLocation from "@ember/routing/none-location";
+    import EmberRoute from "@ember/routing/route";
+    import EmberRouter from "@ember/routing/router";
+    import { controllerFor as emberControllerFor, generateController as emberGenerateController, generateControllerFactory as emberGenerateControllerFactory, DSL as EmberRouterDSL } from "@ember/routing/-internals";
+    import { isNone as emberIsNone, isBlank as emberIsBlank, isEmpty as emberIsEmpty, isPresent as emberIsPresent, isEqual as emberIsEqual, typeOf as emberTypeOf, compare as emberCompare } from "@ember/utils";
+    import * as glimmerRuntime from "@glimmer/runtime";
+    import { helperCapabilities, setModifierManager, setComponentTemplate, getComponentTemplate, setHelperManager } from "@glimmer/manager";
+    import { associateDestroyableChild, registerDestructor, unregisterDestructor } from "@ember/destroyable";
+    import type { precompile, compile } from "ember-template-compiler";
+    import { _impl as EmberTestingImpl } from "@ember/test";
+    namespace Ember {
+        const isNamespace = true;
+        function toString(): string;
+        const Container: typeof InternalContainer;
+        type Container = InternalContainer;
+        const Registry: typeof InternalRegistry;
+        type Registry = InternalRegistry;
+        const _setComponentManager: typeof setComponentManager;
+        const _componentManagerCapabilities: typeof componentCapabilities;
+        const _modifierManagerCapabilities: typeof modifierCapabilities;
+        const meta: {
+            (obj: object): import("@ember/-internals/meta").Meta;
+            _counters?: import("@ember/-internals/meta").MetaCounters | undefined;
+        };
+        const _createCache: typeof metal.createCache;
+        const _cacheGetValue: typeof metal.getValue;
+        const _cacheIsConst: typeof metal.isConst;
+        const _descriptor: typeof metal.nativeDescDecorator;
+        const _getPath: typeof metal._getPath;
+        const _setClassicDecorator: typeof metal.setClassicDecorator;
+        const _tracked: typeof metal.tracked;
+        const beginPropertyChanges: typeof metal.beginPropertyChanges;
+        const changeProperties: typeof metal.changeProperties;
+        const endPropertyChanges: typeof metal.endPropertyChanges;
+        const hasListeners: typeof metal.hasListeners;
+        const libraries: metal.Libraries;
+        const _ContainerProxyMixin: EmberMixin;
+        const _ProxyMixin: EmberMixin;
+        const _RegistryProxyMixin: EmberMixin;
+        const ActionHandler: EmberMixin;
+        type ActionHandler = InternalActionHandler;
+        const Comparable: EmberMixin;
+        type Comparable = InternalComparable;
+        const ComponentLookup: Readonly<typeof EmberObject> & (new (owner?: import("@ember/owner").default | undefined) => EmberObject) & {
+            componentFor(name: string, owner: import("@ember/-internals/owner").InternalOwner): import("@ember/owner").FactoryManager<object> | undefined;
+            layoutFor(name: string, owner: import("@ember/-internals/owner").InternalOwner, options: import("@ember/owner").RegisterOptions): unknown;
+        };
+        const EventDispatcher: typeof views.EventDispatcher;
+        const _Cache: typeof utils.Cache;
+        const GUID_KEY: `__ember${number}`;
+        const canInvoke: typeof utils.canInvoke;
+        const generateGuid: typeof utils.generateGuid;
+        const guidFor: typeof utils.guidFor;
+        const uuid: typeof utils.uuid;
+        const wrap: typeof utils.wrap;
+        const getOwner: (object: object) => import("@ember/owner").default | undefined;
+        const onLoad: typeof applicationOnLoad;
+        const runLoadHooks: typeof applicationRunLoadHooks;
+        const setOwner: typeof import("@ember/owner").setOwner;
+        const Application: typeof EmberApplication;
+        type Application = EmberApplication;
+        const ApplicationInstance: typeof EmberApplicationInstance;
+        type ApplicationInstance = EmberApplicationInstance;
+        const Namespace: typeof EmberNamespace;
+        type Namespace = EmberNamespace;
+        const A: <T>(arr?: T[] | undefined) => EmberNativeArray<T>;
+        const Array: EmberMixin;
+        type Array<T> = EmberArray<T>;
+        const NativeArray: EmberMixin;
+        type NativeArray<T> = EmberNativeArray<T>;
+        const isArray: typeof emberIsArray;
+        const makeArray: typeof emberMakeArray;
+        const MutableArray: EmberMixin;
+        type MutableArray<T> = EmberMutableArray<T>;
+        const ArrayProxy: typeof EmberArrayProxy;
+        type ArrayProxy<T> = EmberArrayProxy<T>;
+        const FEATURES: {
+            isEnabled: typeof isEnabled;
+        };
+        const _Input: EmberInput;
+        const Component: typeof EmberComponent;
+        type Component<S = unknown> = EmberComponent<S>;
+        const Helper: typeof EmberHelper;
+        type Helper<S = unknown> = EmberHelper<S>;
+        const Controller: typeof EmberController;
+        type Controller<T = unknown> = EmberController<T>;
+        const ControllerMixin: EmberMixin;
+        type ControllerMixin<T> = EmberControllerMixin<T>;
+        const _captureRenderTree: typeof EmberDebug.captureRenderTree;
+        const assert: import("@ember/debug/lib/assert").AssertFunc;
+        const warn: import("@ember/debug/lib/warn").WarnFunc;
+        const debug: EmberDebug.DebugFunc;
+        const deprecate: typeof EmberDebug.deprecate;
+        const deprecateFunc: EmberDebug.DeprecateFuncFunc;
+        const runInDebug: EmberDebug.RunInDebugFunc;
+        const inspect: typeof EmberDebug.inspect;
+        const Debug: {
+            registerDeprecationHandler: (handler: import("@ember/debug/lib/handlers").HandlerCallback<EmberDebug.DeprecationOptions>) => void;
+            registerWarnHandler: import("@ember/debug/lib/warn").RegisterHandlerFunc;
+            isComputed: typeof metal.isComputed;
+        };
+        const ContainerDebugAdapter: typeof EmberContainerDebugAdapter;
+        type ContainerDebugAdapter = EmberContainerDebugAdapter;
+        const DataAdapter: typeof EmberDataAdapter;
+        type DataAdapter<T> = EmberDataAdapter<T>;
+        const _assertDestroyablesDestroyed: (() => void) | undefined;
+        const _associateDestroyableChild: typeof associateDestroyableChild;
+        const _enableDestroyableTracking: (() => void) | undefined;
+        const _isDestroying: typeof glimmerRuntime.isDestroying;
+        const _isDestroyed: typeof glimmerRuntime.isDestroyed;
+        const _registerDestructor: typeof registerDestructor;
+        const _unregisterDestructor: typeof unregisterDestructor;
+        const destroy: typeof glimmerRuntime.destroy;
+        const Engine: typeof EmberEngine;
+        type Engine = EmberEngine;
+        const EngineInstance: typeof EmberEngineInstance;
+        type EngineInstance = EmberEngineInstance;
+        const Enumerable: EmberMixin;
+        type Enumerable = EmberEnumerable;
+        const MutableEnumerable: EmberMixin;
+        type MutableEnumerable = EmberMutableEnumerable;
+        /** @private */
+        const instrument: typeof instrumentation.instrument;
+        /** @private */
+        const subscribe: typeof instrumentation.subscribe;
+        /** @private */
+        const Instrumentation: {
+            instrument: typeof instrumentation.instrument;
+            subscribe: typeof instrumentation.subscribe;
+            unsubscribe: typeof instrumentation.unsubscribe;
+            reset: typeof instrumentation.reset;
+        };
+        const Object: typeof EmberObject;
+        type Object = EmberObject;
+        const _action: typeof action;
+        const computed: typeof metal.computed;
+        const defineProperty: typeof metal.defineProperty;
+        const get: typeof metal.get;
+        const getProperties: typeof metal.getProperties;
+        const notifyPropertyChange: typeof metal.notifyPropertyChange;
+        const observer: typeof emberObserver;
+        const set: typeof metal.set;
+        const trySet: typeof metal.trySet;
+        const setProperties: typeof metal.setProperties;
+        const cacheFor: typeof metal.getCachedValueFor;
+        const _dependentKeyCompat: typeof dependentKeyCompat;
+        const ComputedProperty: typeof metal.ComputedProperty;
+        type ComputedProperty = EmberComputedProperty;
+        const expandProperties: typeof metal.expandProperties;
+        const CoreObject: typeof EmberCoreObject;
+        type CoreObject = EmberCoreObject;
+        const Evented: EmberMixin;
+        type Evented = EmberEvented;
+        const on: typeof metal.on;
+        const addListener: typeof metal.addListener;
+        const removeListener: typeof metal.removeListener;
+        const sendEvent: typeof metal.sendEvent;
+        const Mixin: typeof EmberMixin;
+        type Mixin = EmberMixin;
+        const mixin: typeof emberMixin;
+        const Observable: EmberMixin;
+        type Observable = EmberObservable;
+        const addObserver: typeof metal.addObserver;
+        const removeObserver: typeof metal.removeObserver;
+        const PromiseProxyMixin: EmberMixin;
+        type PromiseProxyMixin<T> = EmberPromiseProxyMixin<T>;
+        const ObjectProxy: typeof EmberObjectProxy;
+        type ObjectProxy = EmberObjectProxy;
+        const RouterDSL: typeof EmberRouterDSL;
+        type RouterDSL = EmberRouterDSL;
+        const controllerFor: typeof emberControllerFor;
+        const generateController: typeof emberGenerateController;
+        const generateControllerFactory: typeof emberGenerateControllerFactory;
+        const HashLocation: typeof EmberHashLocation;
+        type HashLocation = EmberHashLocation;
+        const HistoryLocation: typeof EmberHistoryLocation;
+        type HistoryLocation = EmberHistoryLocation;
+        const NoneLocation: typeof EmberNoneLocation;
+        type NoneLocation = EmberNoneLocation;
+        const Route: typeof EmberRoute;
+        type Route = EmberRoute;
+        const Router: typeof EmberRouter;
+        type Router = EmberRouter;
+        const run: typeof emberRun;
+        const Service: typeof EmberService;
+        type Service = EmberService;
+        const compare: typeof emberCompare;
+        const isBlank: typeof emberIsBlank;
+        const isEmpty: typeof emberIsEmpty;
+        const isEqual: typeof emberIsEqual;
+        const isNone: typeof emberIsNone;
+        const isPresent: typeof emberIsPresent;
+        const typeOf: typeof emberTypeOf;
+        /**
+          The semantic version
+      
+          @property VERSION
+          @type String
+          @public
+        */
+        const VERSION: string;
+        const ViewUtils: {
+            getChildViews: typeof views.getChildViews;
+            getElementView: typeof views.getElementView;
+            getRootViews: typeof views.getRootViews;
+            getViewBounds: typeof views.getViewBounds;
+            getViewBoundingClientRect: typeof views.getViewBoundingClientRect;
+            getViewClientRects: typeof views.getViewClientRects;
+            getViewElement: typeof views.getViewElement;
+            isSimpleClick: typeof views.isSimpleClick;
+            isSerializationFirstNode: typeof isSerializationFirstNode;
+        };
+        const _getComponentTemplate: typeof getComponentTemplate;
+        const _helperManagerCapabilities: typeof helperCapabilities;
+        const _setComponentTemplate: typeof setComponentTemplate;
+        const _setHelperManager: typeof setHelperManager;
+        const _setModifierManager: typeof setModifierManager;
+        const _templateOnlyComponent: typeof glimmerRuntime.templateOnlyComponent;
+        const _invokeHelper: typeof glimmerRuntime.invokeHelper;
+        const _hash: object;
+        const _array: object;
+        const _concat: object;
+        const _get: object;
+        const _on: {};
+        const _fn: object;
+        const _Backburner: typeof Backburner;
+        type _Backburner = Backburner;
+        /**
+          Namespace for injection helper methods.
+      
+          @class inject
+          @namespace Ember
+          @static
+          @public
+        */
+        function inject(): void;
+        namespace inject {
+            var controller: typeof injectController;
+            var service: typeof import("@ember/service").service;
+        }
+        const __loader: {
+            readonly require: any;
+            readonly define: any;
+            readonly registry: any;
+        };
+        const ENV: Readonly<object>;
+        let lookup: Record<string, unknown>;
+        /**
+          A function may be assigned to `Ember.onerror` to be called when Ember
+          internals encounter an error. This is useful for specialized error handling
+          and reporting code.
+      
+          ```javascript
+      
+          Ember.onerror = function(error) {
+            const payload = {
+              stack: error.stack,
+              otherInformation: 'whatever app state you want to provide'
+            };
+      
+            fetch('/report-error', {
+              method: 'POST',
+              body: JSON.stringify(payload)
+            });
+          };
+          ```
+      
+          Internally, `Ember.onerror` is used as Backburner's error handler.
+      
+          @event onerror
+          @for Ember
+          @param {Error} error the error object
+          @public
+        */
+        let onerror: ((error: Error) => unknown) | undefined;
+        let testing: boolean;
+        /**
+          Whether searching on the global for new Namespace instances is enabled.
+      
+          This is only exported here as to not break any addons.  Given the new
+          visit API, you will have issues if you treat this as a indicator of
+          booted.
+      
+          Internally this is only exposing a flag in Namespace.
+      
+          @property BOOTED
+          @for Ember
+          @type Boolean
+          @private
+        */
+        let BOOTED: boolean;
+        /**
+          Global hash of shared templates. This will automatically be populated
+          by the build tools so that you can store your Handlebars templates in
+          separate files that get loaded into JavaScript at buildtime.
+      
+          @property TEMPLATES
+          @for Ember
+          @type Object
+          @private
+        */
+        let TEMPLATES: TemplatesRegistry;
+        let HTMLBars: EmberHTMLBars;
+        let Handlebars: EmberHandlebars;
+        let Test: (NonNullable<typeof EmberTestingImpl>["Test"] & {
+            Adapter: NonNullable<typeof EmberTestingImpl>["Adapter"];
+            QUnitAdapter: NonNullable<typeof EmberTestingImpl>["QUnitAdapter"];
+        }) | undefined;
+        let setupForTesting: NonNullable<typeof EmberTestingImpl>["setupForTesting"] | undefined;
+    }
+    namespace Ember {
+        export import RSVP = _RSVP;
+    }
+    interface EmberHandlebars {
+        template: typeof template;
+        Utils: {};
+        compile?: typeof compile;
+        precompile?: typeof precompile;
+    }
+    interface EmberHTMLBars {
+        template: typeof template;
+        compile?: typeof compile;
+        precompile?: typeof precompile;
+    }
+    let EmberHandlebars: EmberHandlebars;
+    let EmberHTMLBars: EmberHTMLBars;
+    export default Ember;
+}

package/external-types/ember-source/types/stable/ember/version.d.ts

@@ -0,0 +1,4 @@
+declare module 'ember/version' {
+    const _default: string;
+    export default _default;
+}

package/external-types/ember-source/types/stable/ember-template-compiler/index.d.ts

@@ -0,0 +1,5 @@
+declare module 'ember-template-compiler' {
+    export * from "ember-template-compiler/lib/public-api";
+    import "ember-template-compiler/lib/system/bootstrap";
+    import "ember-template-compiler/lib/system/initializer";
+}

package/external-types/ember-source/types/stable/ember-template-compiler/lib/-internal.d.ts

@@ -0,0 +1,3 @@
+declare module 'ember-template-compiler/lib/-internal' {
+    export { INTERNAL_PLUGINS } from "@ember/template-compiler/-internal-primitives";
+}

package/external-types/ember-source/types/stable/ember-template-compiler/lib/plugins/assert-against-attrs.d.ts

@@ -0,0 +1,4 @@
+declare module 'ember-template-compiler/lib/plugins/assert-against-attrs' {
+    const _default: typeof import("@ember/template-compiler/lib/plugins/assert-against-attrs").default;
+    export default _default;
+}

package/external-types/ember-source/types/stable/ember-template-compiler/lib/plugins/assert-against-named-outlets.d.ts

@@ -0,0 +1,4 @@
+declare module 'ember-template-compiler/lib/plugins/assert-against-named-outlets' {
+    const _default: typeof import("@ember/template-compiler/lib/plugins/assert-against-named-outlets").default;
+    export default _default;
+}

package/external-types/ember-source/types/stable/ember-template-compiler/lib/plugins/assert-input-helper-without-block.d.ts

@@ -0,0 +1,4 @@
+declare module 'ember-template-compiler/lib/plugins/assert-input-helper-without-block' {
+    const _default: typeof import("@ember/template-compiler/lib/plugins/assert-input-helper-without-block").default;
+    export default _default;
+}

package/external-types/ember-source/types/stable/ember-template-compiler/lib/plugins/assert-reserved-named-arguments.d.ts

@@ -0,0 +1,4 @@
+declare module 'ember-template-compiler/lib/plugins/assert-reserved-named-arguments' {
+    const _default: typeof import("@ember/template-compiler/lib/plugins/assert-reserved-named-arguments").default;
+    export default _default;
+}

package/external-types/ember-source/types/stable/ember-template-compiler/lib/plugins/index.d.ts

@@ -0,0 +1,18 @@
+declare module 'ember-template-compiler/lib/plugins' {
+    export const INTERNAL_PLUGINS: {
+        readonly AssertAgainstAttrs: typeof import("@ember/template-compiler/lib/plugins/assert-against-attrs").default;
+        readonly AssertAgainstNamedOutlets: typeof import("@ember/template-compiler/lib/plugins/assert-against-named-outlets").default;
+        readonly AssertInputHelperWithoutBlock: typeof import("@ember/template-compiler/lib/plugins/assert-input-helper-without-block").default;
+        readonly AssertReservedNamedArguments: typeof import("@ember/template-compiler/lib/plugins/assert-reserved-named-arguments").default;
+        readonly TransformActionSyntax: typeof import("@ember/template-compiler/lib/plugins/transform-action-syntax").default;
+        readonly TransformEachInIntoEach: typeof import("@ember/template-compiler/lib/plugins/transform-each-in-into-each").default;
+        readonly TransformEachTrackArray: typeof import("@ember/template-compiler/lib/plugins/transform-each-track-array").default;
+        readonly TransformInElement: typeof import("@ember/template-compiler/lib/plugins/transform-in-element").default;
+        readonly TransformQuotedBindingsIntoJustBindings: typeof import("@ember/template-compiler/lib/plugins/transform-quoted-bindings-into-just-bindings").default;
+        readonly TransformResolutions: typeof import("@ember/template-compiler/lib/plugins/transform-resolutions").default;
+        readonly TransformWrapMountAndOutlet: typeof import("@ember/template-compiler/lib/plugins/transform-wrap-mount-and-outlet").default;
+    };
+    export const RESOLUTION_MODE_TRANSFORMS: readonly typeof import("@ember/template-compiler/lib/plugins/assert-against-attrs").default[];
+    export const STRICT_MODE_TRANSFORMS: readonly typeof import("@ember/template-compiler/lib/plugins/assert-against-named-outlets").default[];
+    export const STRICT_MODE_KEYWORDS: readonly string[];
+}

package/external-types/ember-source/types/stable/ember-template-compiler/lib/plugins/transform-action-syntax.d.ts

@@ -0,0 +1,4 @@
+declare module 'ember-template-compiler/lib/plugins/transform-action-syntax' {
+    const _default: typeof import("@ember/template-compiler/lib/plugins/transform-action-syntax").default;
+    export default _default;
+}

package/external-types/ember-source/types/stable/ember-template-compiler/lib/plugins/transform-each-in-into-each.d.ts

@@ -0,0 +1,4 @@
+declare module 'ember-template-compiler/lib/plugins/transform-each-in-into-each' {
+    const _default: typeof import("@ember/template-compiler/lib/plugins/transform-each-in-into-each").default;
+    export default _default;
+}

package/external-types/ember-source/types/stable/ember-template-compiler/lib/plugins/transform-each-track-array.d.ts

@@ -0,0 +1,4 @@
+declare module 'ember-template-compiler/lib/plugins/transform-each-track-array' {
+    const _default: typeof import("@ember/template-compiler/lib/plugins/transform-each-track-array").default;
+    export default _default;
+}

package/external-types/ember-source/types/stable/ember-template-compiler/lib/plugins/transform-in-element.d.ts

@@ -0,0 +1,4 @@
+declare module 'ember-template-compiler/lib/plugins/transform-in-element' {
+    const _default: typeof import("@ember/template-compiler/lib/plugins/transform-in-element").default;
+    export default _default;
+}

package/external-types/ember-source/types/stable/ember-template-compiler/lib/plugins/transform-quoted-bindings-into-just-bindings.d.ts

@@ -0,0 +1,4 @@
+declare module 'ember-template-compiler/lib/plugins/transform-quoted-bindings-into-just-bindings' {
+    const _default: typeof import("@ember/template-compiler/lib/plugins/transform-quoted-bindings-into-just-bindings").default;
+    export default _default;
+}

package/external-types/ember-source/types/stable/ember-template-compiler/lib/plugins/transform-resolutions.d.ts

@@ -0,0 +1,4 @@
+declare module 'ember-template-compiler/lib/plugins/transform-resolutions' {
+    const _default: typeof import("@ember/template-compiler/lib/plugins/transform-resolutions").default;
+    export default _default;
+}

package/external-types/ember-source/types/stable/ember-template-compiler/lib/plugins/transform-wrap-mount-and-outlet.d.ts

@@ -0,0 +1,4 @@
+declare module 'ember-template-compiler/lib/plugins/transform-wrap-mount-and-outlet' {
+    const _default: typeof import("@ember/template-compiler/lib/plugins/transform-wrap-mount-and-outlet").default;
+    export default _default;
+}

package/external-types/ember-source/types/stable/ember-template-compiler/lib/plugins/utils.d.ts

@@ -0,0 +1,3 @@
+declare module 'ember-template-compiler/lib/plugins/utils' {
+    export * from "@ember/template-compiler/-internal-utils";
+}

package/external-types/ember-source/types/stable/ember-template-compiler/lib/public-api.d.ts

@@ -0,0 +1,13 @@
+declare module 'ember-template-compiler/lib/public-api' {
+    export { default as _Ember } from "ember";
+    import VERSION from "ember/version";
+    import * as _GlimmerSyntax from "@glimmer/syntax";
+    export { default as precompile } from "ember-template-compiler/lib/system/precompile";
+    export { default as compile } from "ember-template-compiler/lib/system/compile";
+    export { default as compileOptions, buildCompileOptions as _buildCompileOptions, transformsFor as _transformsFor, } from "ember-template-compiler/lib/system/compile-options";
+    export { RESOLUTION_MODE_TRANSFORMS, STRICT_MODE_TRANSFORMS, } from "@ember/template-compiler/-internal-primitives";
+    export type { EmberPrecompileOptions } from "ember-template-compiler/lib/types";
+    export { preprocess as _preprocess, print as _print } from "@glimmer/syntax";
+    export { precompile as _precompile } from "@glimmer/compiler";
+    export { _GlimmerSyntax, VERSION };
+}

package/external-types/ember-source/types/stable/ember-template-compiler/lib/system/bootstrap.d.ts

@@ -0,0 +1,26 @@
+declare module 'ember-template-compiler/lib/system/bootstrap' {
+    /**
+    @module ember
+    */
+    import type { TemplateFactory } from "@glimmer/interfaces";
+    export interface BootstrapOptions {
+        context?: Document | HTMLElement;
+        hasTemplate(templateName: string): boolean;
+        setTemplate(templateName: string, template: TemplateFactory): void;
+    }
+    /**
+      Find templates stored in the head tag as script tags and make them available
+      to `Ember.CoreView` in the global `Ember.TEMPLATES` object.
+
+      Script tags with `text/x-handlebars` will be compiled
+      with Ember's template compiler and are suitable for use as a view's template.
+
+      @private
+      @method bootstrap
+      @for Ember.HTMLBars
+      @static
+      @param ctx
+    */
+    function bootstrap({ context, hasTemplate, setTemplate }: BootstrapOptions): void
+    export default bootstrap;
+}

package/external-types/ember-source/types/stable/ember-template-compiler/lib/system/calculate-location-display.d.ts

@@ -0,0 +1,4 @@
+declare module 'ember-template-compiler/lib/system/calculate-location-display' {
+    import type { AST } from "@glimmer/syntax";
+    export default function calculateLocationDisplay(moduleName: string | undefined, loc?: AST.SourceLocation | undefined): string;
+}

package/external-types/ember-source/types/stable/ember-template-compiler/lib/system/compile-options.d.ts

@@ -0,0 +1,6 @@
+declare module 'ember-template-compiler/lib/system/compile-options' {
+    import type { EmberPrecompileOptions, PluginFunc } from "ember-template-compiler/lib/types";
+    export function buildCompileOptions(_options: EmberPrecompileOptions): EmberPrecompileOptions;
+    export function transformsFor(options: EmberPrecompileOptions): readonly PluginFunc[];
+    export default function compileOptions(_options?: Partial<EmberPrecompileOptions>): EmberPrecompileOptions;
+}

package/external-types/ember-source/types/stable/ember-template-compiler/lib/system/compile.d.ts

@@ -0,0 +1,16 @@
+declare module 'ember-template-compiler/lib/system/compile' {
+    /**
+    @module ember
+    */
+    import type { EmberPrecompileOptions } from "ember-template-compiler/lib/types";
+    import type { TemplateFactory } from "@glimmer/interfaces";
+    /**
+      Uses HTMLBars `compile` function to process a string into a compiled template.
+      This is not present in production builds.
+      @private
+      @method compile
+      @param {String} templateString This is the string to be compiled by HTMLBars.
+      @param {Object} options This is an options hash to augment the compiler options.
+    */
+    export default function compile(templateString: string, options?: Partial<EmberPrecompileOptions>): TemplateFactory;
+}

package/external-types/ember-source/types/stable/ember-template-compiler/lib/system/dasherize-component-name.d.ts

@@ -0,0 +1,5 @@
+declare module 'ember-template-compiler/lib/system/dasherize-component-name' {
+    import { Cache } from "@ember/-internals/utils";
+    const _default: Cache<string, string>;
+    export default _default;
+}

package/external-types/ember-source/types/stable/ember-template-compiler/lib/system/initializer.d.ts

@@ -0,0 +1,3 @@
+declare module 'ember-template-compiler/lib/system/initializer' {
+    export {};
+}

package/external-types/ember-source/types/stable/ember-template-compiler/lib/system/precompile.d.ts

@@ -0,0 +1,17 @@
+declare module 'ember-template-compiler/lib/system/precompile' {
+    /**
+    @module ember
+    */
+    import type { EmberPrecompileOptions } from "ember-template-compiler/lib/types";
+    /**
+      Uses HTMLBars `compile` function to process a string into a compiled template string.
+      The returned string must be passed through `Ember.HTMLBars.template`.
+
+      This is not present in production builds.
+
+      @private
+      @method precompile
+      @param {String} templateString This is the string to be compiled by HTMLBars.
+    */
+    export default function precompile(templateString: string, options?: Partial<EmberPrecompileOptions>): string;
+}

package/external-types/ember-source/types/stable/ember-template-compiler/lib/types.d.ts

@@ -0,0 +1,17 @@
+declare module 'ember-template-compiler/lib/types' {
+    import type { ASTPluginBuilder, ASTPluginEnvironment, builders, PrecompileOptions } from "@glimmer/syntax";
+    export type Builders = typeof builders;
+    export interface PluginFunc extends ASTPluginBuilder<EmberASTPluginEnvironment> {
+    }
+    interface Plugins {
+        ast: PluginFunc[];
+    }
+    export interface EmberPrecompileOptions extends PrecompileOptions {
+        isProduction?: boolean;
+        moduleName?: string;
+        plugins?: Plugins;
+        lexicalScope?: (name: string) => boolean;
+    }
+    export type EmberASTPluginEnvironment = ASTPluginEnvironment & EmberPrecompileOptions;
+    export {};
+}

package/external-types/ember-source/types/stable/ember-template-compiler/minimal.d.ts

@@ -0,0 +1,5 @@
+declare module 'ember-template-compiler/minimal' {
+    export { default as precompile } from "ember-template-compiler/lib/system/precompile";
+    export { buildCompileOptions as _buildCompileOptions } from "ember-template-compiler/lib/system/compile-options";
+    export { preprocess as _preprocess, print as _print } from "@glimmer/syntax";
+}

package/external-types/ember-source/types/stable/ember-testing/index.d.ts

@@ -0,0 +1,3 @@
+declare module 'ember-testing' {
+    export * from "ember-testing/lib/public-api";
+}