@discourse/types 0.0.0 → 0.0.2

package/external-types/ember-source/types/stable/@ember/-internals/container/lib/registry.d.ts

@@ -0,0 +1,280 @@
+declare module '@ember/-internals/container/lib/registry' {
+    import type { Factory, FactoryClass, FullName, InternalFactory, KnownForTypeResult, RegisterOptions, Resolver } from "@ember/-internals/owner";
+    import type { set } from "@ember/object";
+    import type { ContainerOptions, LazyInjection } from "@ember/-internals/container/lib/container";
+    import Container from "@ember/-internals/container/lib/container";
+    export interface Injection {
+        property: string;
+        specifier: FullName;
+    }
+    export interface ResolverClass extends Factory<Resolver>, Partial<{
+        new (...args: any): Resolver;
+    }> {
+    }
+    export interface RegistryOptions {
+        fallback?: Registry;
+        registrations?: {
+            [key: string]: object;
+        };
+        resolver?: Resolver;
+    }
+    /**
+     A registry used to store factory and option information keyed
+     by type.
+
+     A `Registry` stores the factory and option information needed by a
+     `Container` to instantiate and cache objects.
+
+     The API for `Registry` is still in flux and should not be considered stable.
+
+     @private
+     @class Registry
+     @since 1.11.0
+    */
+    export default class Registry {
+        readonly _failSet: Set<string>;
+        resolver: Resolver | null;
+        readonly fallback: Registry | null;
+        readonly registrations: Record<string, InternalFactory<object> | object>;
+        readonly _normalizeCache: Record<FullName, FullName>;
+        readonly _options: Record<string, RegisterOptions>;
+        readonly _resolveCache: Record<string, InternalFactory<object> | object>;
+        readonly _typeOptions: Record<string, RegisterOptions>;
+        set?: typeof set;
+        constructor(options?: RegistryOptions);
+        /**
+         A backup registry for resolving registrations when no matches can be found.
+      
+         @private
+         @property fallback
+         @type Registry
+         */
+        /**
+         An object that has a `resolve` method that resolves a name.
+      
+         @private
+         @property resolver
+         @type Resolver
+         */
+        /**
+         @private
+         @property registrations
+         @type InheritingDict
+         */
+        /**
+         @private
+      
+         @property _normalizeCache
+         @type InheritingDict
+         */
+        /**
+         @private
+      
+         @property _resolveCache
+         @type InheritingDict
+         */
+        /**
+         @private
+      
+         @property _options
+         @type InheritingDict
+         */
+        /**
+         @private
+      
+         @property _typeOptions
+         @type InheritingDict
+         */
+        /**
+         Creates a container based on this registry.
+      
+         @private
+         @method container
+         @param {Object} options
+         @return {Container} created container
+         */
+        container(options?: ContainerOptions): Container;
+        /**
+         Registers a factory for later injection.
+      
+         Example:
+      
+         ```javascript
+         let registry = new Registry();
+      
+         registry.register('model:user', Person, {singleton: false });
+         registry.register('fruit:favorite', Orange);
+         registry.register('communication:main', Email, {singleton: false});
+         ```
+      
+         @private
+         @method register
+         @param {String} fullName
+         @param {Function} factory
+         @param {Object} options
+         */
+        register(fullName: FullName, factory: object, options: RegisterOptions & {
+            instantiate: false;
+        }): void;
+        register<T extends object, C extends FactoryClass | object>(fullName: FullName, factory: InternalFactory<T, C>, options?: RegisterOptions): void;
+        /**
+         Unregister a fullName
+      
+         ```javascript
+         let registry = new Registry();
+         registry.register('model:user', User);
+      
+         registry.resolve('model:user').create() instanceof User //=> true
+      
+         registry.unregister('model:user')
+         registry.resolve('model:user') === undefined //=> true
+         ```
+      
+         @private
+         @method unregister
+         @param {String} fullName
+         */
+        unregister(fullName: FullName): void;
+        /**
+         Given a fullName return the corresponding factory.
+      
+         By default `resolve` will retrieve the factory from
+         the registry.
+      
+         ```javascript
+         let registry = new Registry();
+         registry.register('api:twitter', Twitter);
+      
+         registry.resolve('api:twitter') // => Twitter
+         ```
+      
+         Optionally the registry can be provided with a custom resolver.
+         If provided, `resolve` will first provide the custom resolver
+         the opportunity to resolve the fullName, otherwise it will fallback
+         to the registry.
+      
+         ```javascript
+         let registry = new Registry();
+         registry.resolver = function(fullName) {
+            // lookup via the module system of choice
+          };
+      
+         // the twitter factory is added to the module system
+         registry.resolve('api:twitter') // => Twitter
+         ```
+      
+         @private
+         @method resolve
+         @param {String} fullName
+         @return {Function} fullName's factory
+         */
+        resolve(fullName: FullName): InternalFactory<object> | object | undefined;
+        /**
+         A hook that can be used to describe how the resolver will
+         attempt to find the factory.
+      
+         For example, the default Ember `.describe` returns the full
+         class name (including namespace) where Ember's resolver expects
+         to find the `fullName`.
+      
+         @private
+         @method describe
+         @param {String} fullName
+         @return {string} described fullName
+         */
+        describe(fullName: FullName): string;
+        /**
+         A hook to enable custom fullName normalization behavior
+      
+         @private
+         @method normalizeFullName
+         @param {String} fullName
+         @return {string} normalized fullName
+         */
+        normalizeFullName(fullName: FullName): FullName;
+        /**
+         Normalize a fullName based on the application's conventions
+      
+         @private
+         @method normalize
+         @param {String} fullName
+         @return {string} normalized fullName
+         */
+        normalize(fullName: FullName): FullName;
+        /**
+         @method makeToString
+      
+         @private
+         @param {any} factory
+         @param {string} fullName
+         @return {function} toString function
+         */
+        makeToString(factory: InternalFactory<object>, fullName: FullName): string;
+        /**
+         Given a fullName check if the container is aware of its factory
+         or singleton instance.
+      
+         @private
+         @method has
+         @param {String} fullName
+         @param {Object} [options]
+         @param {String} [options.source] the fullname of the request source (used for local lookups)
+         @return {Boolean}
+         */
+        has(fullName: FullName): boolean;
+        /**
+         Allow registering options for all factories of a type.
+      
+         ```javascript
+         let registry = new Registry();
+         let container = registry.container();
+      
+         // if all of type `connection` must not be singletons
+         registry.optionsForType('connection', { singleton: false });
+      
+         registry.register('connection:twitter', TwitterConnection);
+         registry.register('connection:facebook', FacebookConnection);
+      
+         let twitter = container.lookup('connection:twitter');
+         let twitter2 = container.lookup('connection:twitter');
+      
+         twitter === twitter2; // => false
+      
+         let facebook = container.lookup('connection:facebook');
+         let facebook2 = container.lookup('connection:facebook');
+      
+         facebook === facebook2; // => false
+         ```
+      
+         @private
+         @method optionsForType
+         @param {String} type
+         @param {Object} options
+         */
+        optionsForType(type: string, options: RegisterOptions): void;
+        getOptionsForType(type: string): RegisterOptions | undefined;
+        /**
+         @private
+         @method options
+         @param {String} fullName
+         @param {Object} options
+         */
+        options(fullName: FullName, options: RegisterOptions): void;
+        getOptions(fullName: FullName): RegisterOptions | undefined;
+        getOption<K extends keyof RegisterOptions>(fullName: FullName, optionName: K): RegisterOptions[K] | undefined;
+        /**
+         @private
+         @method knownForType
+         @param {String} type the type to iterate over
+        */
+        knownForType<T extends string>(type: T): KnownForTypeResult<T>;
+        isValidFullName(fullName: string): fullName is FullName;
+    }
+    export class DebugRegistry extends Registry {
+        normalizeInjectionsHash(hash: {
+            [key: string]: LazyInjection;
+        }): Injection[];
+        validateInjections(injections: Injection[]): void;
+    }
+    export function privatize([fullName]: TemplateStringsArray): FullName;
+}

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

@@ -0,0 +1,33 @@
+declare module '@ember/-internals/deprecations' {
+    import type { DeprecationOptions } from "@ember/debug/lib/deprecate";
+    export function emberVersionGte(until: string, emberVersion?: number): boolean;
+    export function isRemoved(options: DeprecationOptions): boolean;
+    interface DeprecationObject {
+        options: DeprecationOptions;
+        test: boolean;
+        isEnabled: boolean;
+        isRemoved: boolean;
+    }
+    export const DEPRECATIONS: {
+        DEPRECATE_IMPORT_EMBER(importName: string): {
+            options: DeprecationOptions;
+            test: boolean;
+            isEnabled: boolean;
+            isRemoved: boolean;
+        };
+        DEPRECATE_ARRAY_PROTOTYPE_EXTENSIONS: {
+            options: DeprecationOptions;
+            test: boolean;
+            isEnabled: boolean;
+            isRemoved: boolean;
+        };
+        DEPRECATE_IMPORT_INJECT: {
+            options: DeprecationOptions;
+            test: boolean;
+            isEnabled: boolean;
+            isRemoved: boolean;
+        };
+    };
+    export function deprecateUntil(message: string, deprecation: DeprecationObject): void;
+    export {};
+}

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

@@ -0,0 +1,5 @@
+declare module '@ember/-internals/environment' {
+    export * from "@ember/-internals/environment/lib/context";
+    export * from "@ember/-internals/environment/lib/env";
+    export { default as global } from "@ember/-internals/environment/lib/global";
+}

package/external-types/ember-source/types/stable/@ember/-internals/environment/lib/context.d.ts

@@ -0,0 +1,10 @@
+declare module '@ember/-internals/environment/lib/context' {
+    export interface GlobalContext {
+        imports: object;
+        exports: object;
+        lookup: Record<string, unknown>;
+    }
+    export const context: GlobalContext;
+    export function getLookup(): Record<string, unknown>;
+    export function setLookup(value: Record<string, unknown>): void;
+}

package/external-types/ember-source/types/stable/@ember/-internals/environment/lib/env.d.ts

@@ -0,0 +1,143 @@
+declare module '@ember/-internals/environment/lib/env' {
+    /**
+      The hash of environment variables used to control various configuration
+      settings. To specify your own or override default settings, add the
+      desired properties to a global hash named `EmberENV` (or `ENV` for
+      backwards compatibility with earlier versions of Ember). The `EmberENV`
+      hash must be created before loading Ember.
+
+      @class EmberENV
+      @type Object
+      @public
+    */
+    export const ENV: {
+        ENABLE_OPTIONAL_FEATURES: boolean;
+        /**
+          Determines whether Ember should add to `Array`
+          native object prototypes, a few extra methods in order to provide a more
+          friendly API.
+      
+          The behavior from setting this option to `true` was deprecated in Ember 5.10.
+      
+          @property EXTEND_PROTOTYPES
+          @type Boolean
+          @default true
+          @for EmberENV
+          @private
+          @deprecated in v5.10
+        */
+        EXTEND_PROTOTYPES: {
+            Array: boolean;
+        };
+        /**
+          The `LOG_STACKTRACE_ON_DEPRECATION` property, when true, tells Ember to log
+          a full stack trace during deprecation warnings.
+      
+          @property LOG_STACKTRACE_ON_DEPRECATION
+          @type Boolean
+          @default true
+          @for EmberENV
+          @public
+        */
+        LOG_STACKTRACE_ON_DEPRECATION: boolean;
+        /**
+          The `LOG_VERSION` property, when true, tells Ember to log versions of all
+          dependent libraries in use.
+      
+          @property LOG_VERSION
+          @type Boolean
+          @default true
+          @for EmberENV
+          @public
+        */
+        LOG_VERSION: boolean;
+        RAISE_ON_DEPRECATION: boolean;
+        STRUCTURED_PROFILE: boolean;
+        /**
+          Whether to perform extra bookkeeping needed to make the `captureRenderTree`
+          API work.
+      
+          This has to be set before the ember JavaScript code is evaluated. This is
+          usually done by setting `window.EmberENV = { _DEBUG_RENDER_TREE: true };`
+          before the "vendor" `<script>` tag in `index.html`.
+      
+          Setting the flag after Ember is already loaded will not work correctly. It
+          may appear to work somewhat, but fundamentally broken.
+      
+          This is not intended to be set directly. Ember Inspector will enable the
+          flag on behalf of the user as needed.
+      
+          This flag is always on in development mode.
+      
+          The flag is off by default in production mode, due to the cost associated
+          with the the bookkeeping work.
+      
+          The expected flow is that Ember Inspector will ask the user to refresh the
+          page after enabling the feature. It could also offer a feature where the
+          user add some domains to the "always on" list. In either case, Ember
+          Inspector will inject the code on the page to set the flag if needed.
+      
+          @property _DEBUG_RENDER_TREE
+          @for EmberENV
+          @type Boolean
+          @default false
+          @private
+        */
+        _DEBUG_RENDER_TREE: boolean;
+        /**
+         Whether to force all deprecations to be enabled. This is used internally by
+         Ember to enable deprecations in tests. It is not intended to be set in
+         projects.
+      
+         @property _ALL_DEPRECATIONS_ENABLED
+         @for EmberENV
+         @type Boolean
+         @default false
+         @private
+         */
+        _ALL_DEPRECATIONS_ENABLED: boolean;
+        /**
+         Override the version of ember-source used to determine when deprecations "break".
+         This is used internally by Ember to test with deprecated features "removed".
+         This is never intended to be set by projects.
+         @property _OVERRIDE_DEPRECATION_VERSION
+         @for EmberENV
+         @type string | null
+         @default null
+         @private
+         */
+        _OVERRIDE_DEPRECATION_VERSION: null;
+        /**
+          Whether the app defaults to using async observers.
+      
+          This is not intended to be set directly, as the implementation may change in
+          the future. Use `@ember/optional-features` instead.
+      
+          @property _DEFAULT_ASYNC_OBSERVERS
+          @for EmberENV
+          @type Boolean
+          @default false
+          @private
+        */
+        _DEFAULT_ASYNC_OBSERVERS: boolean;
+        /**
+          Controls the maximum number of scheduled rerenders without "settling". In general,
+          applications should not need to modify this environment variable, but please
+          open an issue so that we can determine if a better default value is needed.
+      
+          @property _RERENDER_LOOP_LIMIT
+          @for EmberENV
+          @type number
+          @default 1000
+          @private
+         */
+        _RERENDER_LOOP_LIMIT: number;
+        EMBER_LOAD_HOOKS: {
+            [hook: string]: Function[];
+        };
+        FEATURES: {
+            [feature: string]: boolean;
+        };
+    };
+    export function getENV(): object;
+}

package/external-types/ember-source/types/stable/@ember/-internals/environment/lib/global.d.ts

@@ -0,0 +1,4 @@
+declare module '@ember/-internals/environment/lib/global' {
+    const _default: any;
+    export default _default;
+}

package/external-types/ember-source/types/stable/@ember/-internals/error-handling/index.d.ts

@@ -0,0 +1,9 @@
+declare module '@ember/-internals/error-handling' {
+    export const onErrorTarget: {
+        readonly onerror: Function | undefined;
+    };
+    export function getOnerror(): Function | undefined;
+    export function setOnerror(handler: Function | undefined): void;
+    export function getDispatchOverride(): Function | null;
+    export function setDispatchOverride(handler: Function | null): void;
+}