@discourse/types 0.0.0 → 0.0.2

package/external-types/ember-source/types/stable/@ember/-internals/metal/lib/events.d.ts

@@ -0,0 +1,109 @@
+declare module '@ember/-internals/metal/lib/events' {
+    /**
+    @module @ember/object
+    */
+    import type { Meta } from "@ember/-internals/meta";
+    import type { AnyFn } from "@ember/-internals/utility-types";
+    /**
+      Add an event listener
+
+      @method addListener
+      @static
+      @for @ember/object/events
+      @param obj
+      @param {String} eventName
+      @param {Object|Function} target A target object or a function
+      @param {Function|String} method A function or the name of a function to be called on `target`
+      @param {Boolean} once A flag whether a function should only be called once
+      @public
+    */
+    export function addListener(
+      obj: object,
+      eventName: string,
+      target: object | Function | null,
+      method?: Function | PropertyKey,
+      once?: boolean,
+      sync?: boolean
+    ): void;
+    /**
+      Remove an event listener
+
+      Arguments should match those passed to `addListener`.
+
+      @method removeListener
+      @static
+      @for @ember/object/events
+      @param obj
+      @param {String} eventName
+      @param {Object|Function} target A target object or a function
+      @param {Function|String} method A function or the name of a function to be called on `target`
+      @public
+    */
+    export function removeListener(
+      obj: object,
+      eventName: string,
+      targetOrFunction: object | Function | null,
+      functionOrName?: string | Function
+    ): void;
+    /**
+      Send an event. The execution of suspended listeners
+      is skipped, and once listeners are removed. A listener without
+      a target is executed on the passed object. If an array of actions
+      is not passed, the actions stored on the passed object are invoked.
+
+      @method sendEvent
+      @static
+      @for @ember/object/events
+      @param obj
+      @param {String} eventName
+      @param {Array} params Optional parameters for each listener.
+      @return {Boolean} if the event was delivered to one or more actions
+      @public
+    */
+    export function sendEvent(
+      obj: object,
+      eventName: string,
+      params?: any[],
+      actions?: any[],
+      _meta?: Meta | null
+    ): boolean;
+    /**
+      @public
+      @method hasListeners
+      @static
+      @for @ember/object/events
+      @param obj
+      @param {String} eventName
+      @return {Boolean} if `obj` has listeners for event `eventName`
+    */
+    export function hasListeners(obj: object, eventName: string): boolean;
+    /**
+      Define a property as a function that should be executed when
+      a specified event or events are triggered.
+
+      ``` javascript
+      import EmberObject from '@ember/object';
+      import { on } from '@ember/object/evented';
+      import { sendEvent } from '@ember/object/events';
+
+      let Job = EmberObject.extend({
+        logCompleted: on('completed', function() {
+          console.log('Job completed!');
+        })
+      });
+
+      let job = Job.create();
+
+      sendEvent(job, 'completed'); // Logs 'Job completed!'
+     ```
+
+      @method on
+      @static
+      @for @ember/object/evented
+      @param {String} eventNames*
+      @param {Function} func
+      @return {Function} the listener function, passed as last argument to on(...)
+      @public
+    */
+    export function on<T extends AnyFn>(...args: [...eventNames: string[], func: T]): T;
+}

package/external-types/ember-source/types/stable/@ember/-internals/metal/lib/expand_properties.d.ts

@@ -0,0 +1,33 @@
+declare module '@ember/-internals/metal/lib/expand_properties' {
+    /**
+      Expands `pattern`, invoking `callback` for each expansion.
+
+      The only pattern supported is brace-expansion, anything else will be passed
+      once to `callback` directly.
+
+      Example
+
+      ```js
+      import { expandProperties } from '@ember/object/computed';
+
+      function echo(arg){ console.log(arg); }
+
+      expandProperties('foo.bar', echo);              //=> 'foo.bar'
+      expandProperties('{foo,bar}', echo);            //=> 'foo', 'bar'
+      expandProperties('foo.{bar,baz}', echo);        //=> 'foo.bar', 'foo.baz'
+      expandProperties('{foo,bar}.baz', echo);        //=> 'foo.baz', 'bar.baz'
+      expandProperties('foo.{bar,baz}.[]', echo)      //=> 'foo.bar.[]', 'foo.baz.[]'
+      expandProperties('{foo,bar}.{spam,eggs}', echo) //=> 'foo.spam', 'foo.eggs', 'bar.spam', 'bar.eggs'
+      expandProperties('{foo}.bar.{baz}')             //=> 'foo.bar.baz'
+      ```
+
+      @method expandProperties
+      @static
+      @for @ember/object/computed
+      @public
+      @param {String} pattern The property pattern to expand.
+      @param {Function} callback The callback to invoke.  It is invoked once per
+      expansion, and is passed the expansion.
+    */
+    export default function expandProperties(pattern: string, callback: (expansion: string) => void): void;
+}

package/external-types/ember-source/types/stable/@ember/-internals/metal/lib/get_properties.d.ts

@@ -0,0 +1,38 @@
+declare module '@ember/-internals/metal/lib/get_properties' {
+    /**
+     @module @ember/object
+    */
+    /**
+      To get multiple properties at once, call `getProperties`
+      with an object followed by a list of strings or an array:
+
+      ```javascript
+      import { getProperties } from '@ember/object';
+
+      getProperties(record, 'firstName', 'lastName', 'zipCode');
+      // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
+      ```
+
+      is equivalent to:
+
+      ```javascript
+      import { getProperties } from '@ember/object';
+
+      getProperties(record, ['firstName', 'lastName', 'zipCode']);
+      // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
+      ```
+
+      @method getProperties
+      @static
+      @for @ember/object
+      @param {Object} obj
+      @param {String...|Array} list of keys to get
+      @return {Object}
+      @public
+    */
+    function getProperties<T, K extends keyof T>(obj: T, list: K[]): Pick<T, K>
+    function getProperties<T, K extends keyof T>(obj: T, ...list: K[]): Pick<T, K>
+    function getProperties<K extends string>(obj: unknown, list: K[]): Record<K, unknown>
+    function getProperties<K extends string>(obj: unknown, ...list: K[]): Record<K, unknown>
+    export default getProperties;
+}

package/external-types/ember-source/types/stable/@ember/-internals/metal/lib/injected_property.d.ts

@@ -0,0 +1,25 @@
+declare module '@ember/-internals/metal/lib/injected_property' {
+    import type { DecoratorPropertyDescriptor, ElementDescriptor } from "@ember/-internals/metal/lib/decorator";
+    export let DEBUG_INJECTION_FUNCTIONS: WeakMap<Function, any>;
+    /**
+     @module ember
+     @private
+     */
+    /**
+      Read-only property that returns the result of a container lookup.
+
+      @class InjectedProperty
+      @namespace Ember
+      @constructor
+      @param {String} type The container type the property will lookup
+      @param {String} nameOrDesc (optional) The name the property will lookup, defaults
+             to the property's name
+      @private
+    */
+    function inject(type: string, name: string): PropertyDecorator
+    function inject(type: string): PropertyDecorator
+    function inject(type: string, ...args: [ElementDescriptor[0], ElementDescriptor[1]]): void
+    function inject(type: string, ...args: ElementDescriptor): DecoratorPropertyDescriptor
+    function inject(type: string, ...args: [] | [name: string] | ElementDescriptor): PropertyDecorator | DecoratorPropertyDescriptor | void
+    export default inject;
+}

package/external-types/ember-source/types/stable/@ember/-internals/metal/lib/libraries.d.ts

@@ -0,0 +1,31 @@
+declare module '@ember/-internals/metal/lib/libraries' {
+    interface Library {
+        readonly name: string;
+        readonly version: string;
+    }
+    /**
+     @module ember
+    */
+    /**
+      Helper class that allows you to register your library with Ember.
+
+      Singleton created at `Ember.libraries`.
+
+      @class Libraries
+      @constructor
+      @private
+    */
+    export class Libraries {
+        readonly _registry: Library[];
+        _coreLibIndex: number;
+        constructor();
+        _getLibraryByName(name: string): Library | undefined;
+        register(name: string, version: string, isCoreLibrary?: boolean): void;
+        registerCoreLibrary(name: string, version: string): void;
+        deRegister(name: string): void;
+        isRegistered?: (name: string) => boolean;
+        logVersions?: () => void;
+    }
+    const LIBRARIES: Libraries;
+    export default LIBRARIES;
+}

package/external-types/ember-source/types/stable/@ember/-internals/metal/lib/namespace_search.d.ts

@@ -0,0 +1,19 @@
+declare module '@ember/-internals/metal/lib/namespace_search' {
+    export interface Namespace {
+        isNamespace: true;
+        destroy(): void;
+    }
+    export const NAMESPACES: Namespace[];
+    export const NAMESPACES_BY_ID: {
+        [name: string]: Namespace;
+    };
+    export function addNamespace(namespace: Namespace): void;
+    export function removeNamespace(namespace: Namespace): void;
+    export function findNamespaces(): void;
+    export function findNamespace(name: string): Namespace | undefined;
+    export function processNamespace(namespace: Namespace): void;
+    export function processAllNamespaces(): void;
+    export function isSearchDisabled(): boolean;
+    export function setSearchDisabled(flag: boolean): void;
+    export function setUnprocessedMixins(): void;
+}

package/external-types/ember-source/types/stable/@ember/-internals/metal/lib/object-at.d.ts

@@ -0,0 +1,4 @@
+declare module '@ember/-internals/metal/lib/object-at' {
+    import type EmberArray from "@ember/array";
+    export function objectAt<T>(array: T[] | EmberArray<T>, index: number): T | undefined;
+}

package/external-types/ember-source/types/stable/@ember/-internals/metal/lib/observer.d.ts

@@ -0,0 +1,67 @@
+declare module '@ember/-internals/metal/lib/observer' {
+    import type { schedule } from "@ember/runloop";
+    import type { Tag } from "@glimmer/validator";
+    interface ActiveObserver {
+        tag: Tag;
+        path: string;
+        lastRevision: number;
+        count: number;
+        suspended: boolean;
+    }
+    export const SYNC_OBSERVERS: Map<object, Map<string, ActiveObserver>>;
+    export const ASYNC_OBSERVERS: Map<object, Map<string, ActiveObserver>>;
+    /**
+    @module @ember/object
+    */
+    /**
+      @method addObserver
+      @static
+      @for @ember/object/observers
+      @param obj
+      @param {String} path
+      @param {Object|Function} target
+      @param {Function|String} [method]
+      @public
+    */
+    export function addObserver(
+      obj: any,
+      path: string,
+      target: object | Function | null,
+      method?: string | Function,
+      sync?: boolean
+    ): void;
+    /**
+      @method removeObserver
+      @static
+      @for @ember/object/observers
+      @param obj
+      @param {String} path
+      @param {Object|Function} target
+      @param {Function|String} [method]
+      @public
+    */
+    export function removeObserver(
+      obj: any,
+      path: string,
+      target: object | Function | null,
+      method?: string | Function,
+      sync?: boolean
+    ): void;
+    export function activateObserver(target: object, eventName: string, sync?: boolean): void;
+    export function deactivateObserver(target: object, eventName: string, sync?: boolean): void;
+    export function suspendedObserverDeactivation(): void;
+    export function resumeObserverDeactivation(): void;
+    /**
+     * Primarily used for cases where we are redefining a class, e.g. mixins/reopen
+     * being applied later. Revalidates all the observers, resetting their tags.
+     *
+     * @private
+     * @param target
+     */
+    export function revalidateObservers(target: object): void;
+    export function flushAsyncObservers(_schedule: typeof schedule | false): void;
+    export function flushSyncObservers(): void;
+    export function setObserverSuspended(target: object, property: string, suspended: boolean): void;
+    export function destroyObservers(target: object): void;
+    export {};
+}

package/external-types/ember-source/types/stable/@ember/-internals/metal/lib/path_cache.d.ts

@@ -0,0 +1,3 @@
+declare module '@ember/-internals/metal/lib/path_cache' {
+    export function isPath(path: unknown): boolean;
+}

package/external-types/ember-source/types/stable/@ember/-internals/metal/lib/properties.d.ts

@@ -0,0 +1,70 @@
+declare module '@ember/-internals/metal/lib/properties' {
+    /**
+    @module @ember/object
+    */
+    import type { Meta } from "@ember/-internals/meta";
+    import type { ExtendedMethodDecorator } from "@ember/-internals/metal/lib/decorator";
+    /**
+      NOTE: This is a low-level method used by other parts of the API. You almost
+      never want to call this method directly. Instead you should use
+      `mixin()` to define new properties.
+
+      Defines a property on an object. This method works much like the ES5
+      `Object.defineProperty()` method except that it can also accept computed
+      properties and other special descriptors.
+
+      Normally this method takes only three parameters. However if you pass an
+      instance of `Descriptor` as the third param then you can pass an
+      optional value as the fourth parameter. This is often more efficient than
+      creating new descriptor hashes for each property.
+
+      ## Examples
+
+      ```javascript
+      import { defineProperty, computed } from '@ember/object';
+
+      // ES5 compatible mode
+      defineProperty(contact, 'firstName', {
+        writable: true,
+        configurable: false,
+        enumerable: true,
+        value: 'Charles'
+      });
+
+      // define a simple property
+      defineProperty(contact, 'lastName', undefined, 'Jolley');
+
+      // define a computed property
+      defineProperty(contact, 'fullName', computed('firstName', 'lastName', function() {
+        return this.firstName+' '+this.lastName;
+      }));
+      ```
+
+      @public
+      @method defineProperty
+      @static
+      @for @ember/object
+      @param {Object} obj the object to define this property on. This may be a prototype.
+      @param {String} keyName the name of the property
+      @param {Descriptor} [desc] an instance of `Descriptor` (typically a
+        computed property) or an ES5 descriptor.
+        You must provide this or `data` but not both.
+      @param {*} [data] something other than a descriptor, that will
+        become the explicit value of this property.
+    */
+    export function defineProperty(
+      obj: object,
+      keyName: string,
+      desc?: ExtendedMethodDecorator | PropertyDescriptor | undefined | null,
+      data?: any | undefined | null,
+      _meta?: Meta
+    ): void;
+    export function defineDecorator(obj: object, keyName: string, desc: ExtendedMethodDecorator, meta: Meta): ExtendedMethodDecorator;
+    export function defineValue(
+      obj: object,
+      keyName: string,
+      value: unknown,
+      wasDescriptor: boolean,
+      enumerable?: boolean
+    ): unknown;
+}

package/external-types/ember-source/types/stable/@ember/-internals/metal/lib/property_events.d.ts

@@ -0,0 +1,59 @@
+declare module '@ember/-internals/metal/lib/property_events' {
+    import type { Meta } from "@ember/-internals/meta";
+    /**
+     @module ember
+     @private
+     */
+    export const PROPERTY_DID_CHANGE: unique symbol;
+    export interface PropertyDidChange {
+        [PROPERTY_DID_CHANGE]: (keyName: string, value?: unknown) => void;
+    }
+    export function hasPropertyDidChange(obj: unknown): obj is PropertyDidChange;
+    /**
+      This function is called just after an object property has changed.
+      It will notify any observers and clear caches among other things.
+
+      Normally you will not need to call this method directly but if for some
+      reason you can't directly watch a property you can invoke this method
+      manually.
+
+      @method notifyPropertyChange
+      @for @ember/object
+      @param {Object} obj The object with the property that will change
+      @param {String} keyName The property key (or path) that will change.
+      @param {Meta} [_meta] The objects meta.
+      @param {unknown} [value] The new value to set for the property
+      @return {void}
+      @since 3.1.0
+      @public
+    */
+    function notifyPropertyChange(obj: object, keyName: string, _meta?: Meta | null, value?: unknown): void
+    /**
+      @method beginPropertyChanges
+      @chainable
+      @private
+    */
+    function beginPropertyChanges(): void
+    /**
+      @method endPropertyChanges
+      @private
+    */
+    function endPropertyChanges(): void
+    /**
+      Make a series of property changes together in an
+      exception-safe way.
+
+      ```javascript
+      Ember.changeProperties(function() {
+        obj1.set('foo', mayBlowUpWhenSet);
+        obj2.set('bar', baz);
+      });
+      ```
+
+      @method changeProperties
+      @param {Function} callback
+      @private
+    */
+    function changeProperties(callback: () => void): void
+    export { notifyPropertyChange, beginPropertyChanges, endPropertyChanges, changeProperties };
+}

package/external-types/ember-source/types/stable/@ember/-internals/metal/lib/property_get.d.ts

@@ -0,0 +1,44 @@
+declare module '@ember/-internals/metal/lib/property_get' {
+    export const PROXY_CONTENT: symbol;
+    export let getPossibleMandatoryProxyValue: (obj: object, keyName: string) => any;
+    export interface HasUnknownProperty {
+        unknownProperty: (keyName: string) => any;
+    }
+    export function hasUnknownProperty(val: unknown): val is HasUnknownProperty;
+    /**
+      Gets the value of a property on an object. If the property is computed,
+      the function will be invoked. If the property is not defined but the
+      object implements the `unknownProperty` method then that will be invoked.
+
+      ```javascript
+      import { get } from '@ember/object';
+      get(obj, "name");
+      ```
+
+      If you plan to run on IE8 and older browsers then you should use this
+      method anytime you want to retrieve a property on an object that you don't
+      know for sure is private. (Properties beginning with an underscore '_'
+      are considered private.)
+
+      On all newer browsers, you only need to use this method to retrieve
+      properties if the property might not be defined on the object and you want
+      to respect the `unknownProperty` handler. Otherwise you can ignore this
+      method.
+
+      Note that if the object itself is `undefined`, this method will throw
+      an error.
+
+      @method get
+      @for @ember/object
+      @static
+      @param {Object} obj The object to retrieve from.
+      @param {String} keyName The property key to retrieve
+      @return {Object} the property value or `null`.
+      @public
+    */
+    export function get<T extends object, K extends keyof T>(obj: T, keyName: K): T[K];
+    export function get(obj: unknown, keyName: string): unknown;
+    export function _getProp(obj: unknown, keyName: string): unknown;
+    export function _getPath(obj: unknown, path: string | string[], forSet?: boolean): any;
+    export default get;
+}

package/external-types/ember-source/types/stable/@ember/-internals/metal/lib/property_set.d.ts

@@ -0,0 +1,52 @@
+declare module '@ember/-internals/metal/lib/property_set' {
+    /**
+     @module @ember/object
+    */
+    /**
+      Sets the value of a property on an object, respecting computed properties
+      and notifying observers and other listeners of the change.
+      If the specified property is not defined on the object and the object
+      implements the `setUnknownProperty` method, then instead of setting the
+      value of the property on the object, its `setUnknownProperty` handler
+      will be invoked with the two parameters `keyName` and `value`.
+
+      ```javascript
+      import { set } from '@ember/object';
+      set(obj, "name", value);
+      ```
+
+      @method set
+      @static
+      @for @ember/object
+      @param {Object} obj The object to modify.
+      @param {String} keyName The property key to set
+      @param {Object} value The value to set
+      @return {Object} the passed value.
+      @public
+    */
+    export function set<T>(obj: object, keyName: string, value: T, tolerant?: boolean): T;
+    export function _setProp(obj: object, keyName: string, value: any): any;
+    /**
+      Error-tolerant form of `set`. Will not blow up if any part of the
+      chain is `undefined`, `null`, or destroyed.
+
+      This is primarily used when syncing bindings, which may try to update after
+      an object has been destroyed.
+
+      ```javascript
+      import { trySet } from '@ember/object';
+
+      let obj = { name: "Zoey" };
+      trySet(obj, "contacts.twitter", "@emberjs");
+      ```
+
+      @method trySet
+      @static
+      @for @ember/object
+      @param {Object} root The object to modify.
+      @param {String} path The property path to set
+      @param {Object} value The value to set
+      @public
+    */
+    export function trySet<T>(root: object, path: string, value: T): T | undefined;
+}

package/external-types/ember-source/types/stable/@ember/-internals/metal/lib/set_properties.d.ts

@@ -0,0 +1,32 @@
+declare module '@ember/-internals/metal/lib/set_properties' {
+    /**
+     @module @ember/object
+    */
+    /**
+      Set a list of properties on an object. These properties are set inside
+      a single `beginPropertyChanges` and `endPropertyChanges` batch, so
+      observers will be buffered.
+
+      ```javascript
+      import EmberObject from '@ember/object';
+      let anObject = EmberObject.create();
+
+      anObject.setProperties({
+        firstName: 'Stanley',
+        lastName: 'Stuart',
+        age: 21
+      });
+      ```
+
+      @method setProperties
+      @static
+      @for @ember/object
+      @param obj
+      @param {Object} properties
+      @return properties
+      @public
+    */
+    function setProperties<T, K extends keyof T>(obj: T, properties: Pick<T, K>): Pick<T, K>
+    function setProperties<T extends Record<string, unknown>>(obj: object, properties: T): T
+    export default setProperties;
+}

package/external-types/ember-source/types/stable/@ember/-internals/metal/lib/tags.d.ts

@@ -0,0 +1,12 @@
+declare module '@ember/-internals/metal/lib/tags' {
+    import type { Tag, TagMeta } from "@glimmer/validator";
+    export const SELF_TAG: string | symbol;
+    export function tagForProperty(
+      obj: object,
+      propertyKey: string | symbol,
+      addMandatorySetter?: boolean,
+      meta?: TagMeta
+    ): Tag;
+    export function tagForObject(obj: unknown | null): Tag;
+    export function markObjectAsDirty(obj: object, propertyKey: string): void;
+}