ember-source 4.8.0-alpha.5 → 4.8.0-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ember-source",
-  "version": "4.8.0-alpha.5",
+  "version": "4.8.0-beta.2",
   "description": "A JavaScript framework for creating ambitious web applications",
   "keywords": [
     "ember-addon"
@@ -25,7 +25,8 @@
     "dist/ember-testing.js",
     "dist/ember-testing.map",
     "docs/data.json",
-    "lib"
+    "lib",
+    "types"
   ],
   "repository": {
     "type": "git",
@@ -40,7 +41,9 @@
     "lint:docs": "qunit tests/docs/coverage-test.js",
     "lint:eslint": "eslint --report-unused-disable-directives --cache .",
     "lint:eslint:fix": "npm-run-all \"lint:eslint --fix\"",
-    "lint:tsc": "tsc --noEmit",
+    "lint:tsc:stable": "tsc --noEmit",
+    "lint:tsc:preview": "tsc --noEmit --project type-tests/preview",
+    "lint:tsc": "npm-run-all lint:tsc:*",
     "lint:fix": "npm-run-all lint:*:fix",
     "test": "node bin/run-tests.js",
     "test:blueprints:js": "mocha node-tests/blueprints/**/*-test.js",
@@ -80,6 +83,7 @@
   "devDependencies": {
     "@babel/preset-env": "^7.16.11",
     "@glimmer/compiler": "0.84.2",
+    "@glimmer/component": "^1.1.2",
     "@glimmer/destroyable": "0.84.2",
     "@glimmer/env": "^0.1.7",
     "@glimmer/global-context": "0.84.2",
@@ -93,7 +97,8 @@
     "@glimmer/runtime": "0.84.2",
     "@glimmer/validator": "0.84.2",
     "@simple-dom/document": "^1.4.0",
-    "@types/qunit": "^2.11.3",
+    "@tsconfig/ember": "^1.0.1",
+    "@types/qunit": "^2.19.2",
     "@types/rsvp": "^4.0.4",
     "@typescript-eslint/eslint-plugin": "^5.22.0",
     "@typescript-eslint/parser": "^5.15.0",
@@ -142,11 +147,11 @@
     "npm-run-all": "^4.1.5",
     "prettier": "^2.7.1",
     "puppeteer": "^13.5.1",
-    "qunit": "^2.18.1",
+    "qunit": "^2.19.1",
     "rollup-plugin-commonjs": "^9.3.4",
     "rollup-plugin-node-resolve": "^4.2.4",
     "route-recognizer": "^0.3.4",
-    "router_js": "^8.0.2",
+    "router_js": "^8.0.3",
     "rsvp": "^4.8.5",
     "serve-static": "^1.14.2",
     "simple-dom": "^1.4.0",
@@ -154,15 +159,25 @@
     "testem-failure-only-reporter": "^1.0.0",
     "typescript": "~4.6.4"
   },
+  "peerDependencies": {
+    "@glimmer/component": "^1.1.2"
+  },
   "engines": {
     "node": ">= 12.*"
   },
   "ember-addon": {
     "after": "ember-cli-legacy-blueprints"
   },
-  "_originalVersion": "4.8.0-alpha.5",
+  "typesVersions": {
+    "*": {
+      "preview": [
+        "./types/preview"
+      ]
+    }
+  },
+  "_originalVersion": "4.8.0-beta.2",
   "_versionPreviouslyCalculated": true,
   "publishConfig": {
-    "tag": "alpha"
+    "tag": "beta"
   }
 }

package/types/preview/@ember/-internals/resolver.d.ts

@@ -0,0 +1,35 @@
+declare module '@ember/-internals/resolver' {
+  /**
+   * @module
+   * @private This is not a public API module, and in fact ***there is no such
+   *   module at runtime***. This module exists only to provide a public API for
+   *   `Resolver`, which will get a dedicated home as part of Ember's public API
+   *   via a future RFC. As an end user, if you need access to `Resolver` for now
+   *   you should ordinarily get it via `ember-resolver`.
+   */
+
+  import EmberObject from '@ember/object';
+  import type { Factory, FullName } from '@ember/owner';
+
+  export type KnownForTypeResult<Type extends string> = {
+    [fullName in `${Type}:${string}`]: boolean | undefined;
+  };
+
+  /**
+   * A `Resolver` is the mechanism responsible for looking up code in your
+   * application and converting its naming conventions into the actual classes,
+   * functions, and templates that Ember needs to resolve its dependencies, for
+   * example, what template to render for a given route. It is a system that helps
+   * the app resolve the lookup of JavaScript modules agnostic of what kind of
+   * module system is used, which can be AMD, CommonJS or just plain globals. It
+   * is used to lookup routes, models, components, templates, or anything that is
+   * used in your Ember app.
+   */
+  export interface Resolver extends EmberObject {
+    knownForType?: <TypeName extends string>(type: TypeName) => KnownForTypeResult<TypeName>;
+    lookupDescription?: (fullName: FullName) => string;
+    makeToString?: (factory: Factory<object>, fullName: FullName) => string;
+    normalize?: (fullName: FullName) => string;
+    resolve(name: string): Factory<object> | object | undefined;
+  }
+}

package/types/preview/@ember/application/-private/event-dispatcher.d.ts

@@ -0,0 +1,18 @@
+declare module '@ember/application/-private/event-dispatcher' {
+  import { EventDispatcherEvents } from '@ember/application/types';
+
+  /**
+   * `Ember.EventDispatcher` handles delegating browser events to their
+   * corresponding `Ember.Views.` For example, when you click on a view,
+   * `Ember.EventDispatcher` ensures that that view's `mouseDown` method gets
+   * called.
+   */
+  export default class EventDispatcher extends Object {
+    /**
+     * The set of events names (and associated handler function names) to be setup
+     * and dispatched by the `EventDispatcher`. Modifications to this list can be done
+     * at setup time, generally via the `Ember.Application.customEvents` hash.
+     */
+    events: EventDispatcherEvents;
+  }
+}

package/types/preview/@ember/application/-private/registry.d.ts

@@ -0,0 +1,15 @@
+declare module '@ember/application/-private/registry' {
+  import { EmberClassConstructor } from '@ember/object/-private/types';
+
+  /**
+   * A registry used to store factory and option information keyed
+   * by type.
+   */
+  export default class Registry {
+    register(
+      fullName: string,
+      factory: EmberClassConstructor<unknown>,
+      options?: { singleton?: boolean | undefined }
+    ): void;
+  }
+}

package/types/preview/@ember/application/deprecations.d.ts

@@ -0,0 +1,24 @@
+declare module '@ember/application/deprecations' {
+  import { AnyFn } from 'ember/-private/type-utils';
+
+  interface DeprecationOptions {
+    id: string;
+    until: string;
+    url?: string | undefined;
+  }
+
+  /**
+   * Display a deprecation warning with the provided message and a stack trace
+   * (Chrome and Firefox only).
+   */
+  export function deprecate(message: string, test: boolean, options: DeprecationOptions): void;
+
+  /**
+   * Alias an old, deprecated method with its new counterpart.
+   */
+  export function deprecateFunc<Func extends AnyFn>(
+    message: string,
+    options: DeprecationOptions,
+    func: Func
+  ): Func;
+}

package/types/preview/@ember/application/index.d.ts

@@ -0,0 +1,153 @@
+declare module '@ember/application' {
+  import Engine from '@ember/engine';
+  import ApplicationInstance from '@ember/application/instance';
+  import EventDispatcher from '@ember/application/-private/event-dispatcher';
+  import { EventDispatcherEvents } from '@ember/application/types';
+  import { Router } from '@ember/routing';
+  import Registry from '@ember/application/-private/registry';
+  import type { Resolver } from '@ember/-internals/resolver';
+  import { AnyFn } from 'ember/-private/type-utils';
+  import Owner from '@ember/owner';
+  import type GlimmerComponent from '@glimmer/component';
+  import EmberObject from '@ember/object';
+
+  // Shut off default exporting; we don't want anything but the *intended*
+  // public API present.
+  export {};
+
+  /**
+   * An instance of Ember.Application is the starting point for every Ember application. It helps to
+   * instantiate, initialize and coordinate the many objects that make up your app.
+   */
+  export default class Application extends Engine {
+    /**
+     * Call advanceReadiness after any asynchronous setup logic has completed.
+     * Each call to deferReadiness must be matched by a call to advanceReadiness
+     * or the application will never become ready and routing will not begin.
+     */
+    advanceReadiness(): void;
+    /**
+     * Use this to defer readiness until some condition is true.
+     *
+     * This allows you to perform asynchronous setup logic and defer
+     * booting your application until the setup has finished.
+     *
+     * However, if the setup requires a loading UI, it might be better
+     * to use the router for this purpose.
+     */
+    deferReadiness(): void;
+    /**
+     * defines an injection or typeInjection
+     */
+    inject(factoryNameOrType: string, property: string, injectionName: string): void;
+    /**
+     * This injects the test helpers into the window's scope. If a function of the
+     * same name has already been defined it will be cached (so that it can be reset
+     * if the helper is removed with `unregisterHelper` or `removeTestHelpers`).
+     * Any callbacks registered with `onInjectHelpers` will be called once the
+     * helpers have been injected.
+     */
+    injectTestHelpers(): void;
+    /**
+     * registers a factory for later injection
+     * @param fullName type:name (e.g., 'model:user')
+     * @param factory (e.g., App.Person)
+     */
+    register(
+      fullName: string,
+      factory: unknown,
+      options?: { singleton?: boolean | undefined; instantiate?: boolean | undefined }
+    ): void;
+    /**
+     * This removes all helpers that have been registered, and resets and functions
+     * that were overridden by the helpers.
+     */
+    removeTestHelpers(): void;
+    /**
+     * Reset the application. This is typically used only in tests.
+     */
+    reset(): void;
+    /**
+     * This hook defers the readiness of the application, so that you can start
+     * the app when your tests are ready to run. It also sets the router's
+     * location to 'none', so that the window's location will not be modified
+     * (preventing both accidental leaking of state between tests and interference
+     * with your testing framework).
+     */
+    setupForTesting(): void;
+    /**
+     * The DOM events for which the event dispatcher should listen.
+     */
+    customEvents: EventDispatcherEvents;
+    /**
+     * The Ember.EventDispatcher responsible for delegating events to this application's views.
+     */
+    eventDispatcher: EventDispatcher;
+    /**
+     * Set this to provide an alternate class to `DefaultResolver`
+     */
+    resolver: Resolver | null;
+    /**
+     * The root DOM element of the Application. This can be specified as an
+     * element or a jQuery-compatible selector string.
+     *
+     * This is the element that will be passed to the Application's, eventDispatcher,
+     * which sets up the listeners for event delegation. Every view in your application
+     * should be a child of the element you specify here.
+     */
+    rootElement: HTMLElement | string;
+    /**
+     * Called when the Application has become ready.
+     * The call will be delayed until the DOM has become ready.
+     */
+    ready: AnyFn;
+    /**
+     * Application's router.
+     */
+    Router: Router;
+    registry: Registry;
+    /**
+     *  Initialize the application and return a promise that resolves with the `Application`
+     *  object when the boot process is complete.
+     */
+    boot(): Promise<Application>;
+    /**
+     * Create an ApplicationInstance for this Application.
+     */
+    buildInstance(options?: object): ApplicationInstance;
+  }
+
+  // Known framework objects, so that `getOwner` can always, accurately, return
+  // `Owner` when working with one of these classes, which the framework *does*
+  // guarantee will always have an `Owner`. NOTE: this must be kept up to date
+  // whenever we add new base classes to the framework. For example, if we
+  // introduce a standalone `Service` or `Route` base class which *does not*
+  // extend from `EmberObject`, it will need to be added here.
+  type FrameworkObject = EmberObject | GlimmerComponent;
+
+  /**
+   * Framework objects in an Ember application (components, services, routes, etc.)
+   * are created via a factory and dependency injection system. Each of these
+   * objects is the responsibility of an "owner", which handled its
+   * instantiation and manages its lifetime.
+   */
+  export function getOwner(object: FrameworkObject): Owner;
+  export function getOwner(object: unknown): Owner | undefined;
+  /**
+   * `setOwner` forces a new owner on a given object instance. This is primarily
+   * useful in some testing cases.
+   */
+  export function setOwner(object: unknown, owner: Owner): void;
+
+  /**
+   * Detects when a specific package of Ember (e.g. 'Ember.Application')
+   * has fully loaded and is available for extension.
+   */
+  export function onLoad(name: string, callback: AnyFn): unknown;
+
+  /**
+   * Called when an Ember.js package (e.g Ember.Application) has finished
+   * loading. Triggers any callbacks registered for this event.
+   */
+  export function runLoadHooks(name: string, object?: {}): unknown;
+}

package/types/preview/@ember/application/instance.d.ts

@@ -0,0 +1,9 @@
+declare module '@ember/application/instance' {
+  import EngineInstance from '@ember/engine/instance';
+
+  /**
+   * The `ApplicationInstance` encapsulates all of the stateful aspects of a
+   * running `Application`.
+   */
+  export default class ApplicationInstance extends EngineInstance {}
+}

package/types/preview/@ember/application/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.json"
+}

package/types/preview/@ember/application/types.d.ts

@@ -0,0 +1,29 @@
+declare module '@ember/application/types' {
+  export interface EventDispatcherEvents {
+    touchstart?: string | null | undefined;
+    touchmove?: string | null | undefined;
+    touchend?: string | null | undefined;
+    touchcancel?: string | null | undefined;
+    keydown?: string | null | undefined;
+    keyup?: string | null | undefined;
+    keypress?: string | null | undefined;
+    mousedown?: string | null | undefined;
+    mouseup?: string | null | undefined;
+    contextmenu?: string | null | undefined;
+    click?: string | null | undefined;
+    dblclick?: string | null | undefined;
+    focusin?: string | null | undefined;
+    focusout?: string | null | undefined;
+    submit?: string | null | undefined;
+    input?: string | null | undefined;
+    change?: string | null | undefined;
+    dragstart?: string | null | undefined;
+    drag?: string | null | undefined;
+    dragenter?: string | null | undefined;
+    dragleave?: string | null | undefined;
+    dragover?: string | null | undefined;
+    drop?: string | null | undefined;
+    dragend?: string | null | undefined;
+    [event: string]: string | null | undefined;
+  }
+}

package/types/preview/@ember/array/-private/enumerable.d.ts

@@ -0,0 +1,13 @@
+declare module '@ember/array/-private/enumerable' {
+  import Mixin from '@ember/object/mixin';
+
+  /**
+   * The methods in this mixin have been moved to `MutableArray`. This mixin has
+   * been intentionally preserved to avoid breaking `Enumerable.detect` checks
+   * until the community migrates away from them.
+   */
+  interface Enumerable {}
+
+  const Enumerable: Mixin;
+  export default Enumerable;
+}

package/types/preview/@ember/array/-private/mutable-enumerable.d.ts

@@ -0,0 +1,13 @@
+declare module '@ember/array/-private/mutable-enumerable' {
+  import Mixin from '@ember/object/mixin';
+  import Enumerable from '@ember/array/-private/enumerable';
+
+  /**
+   * This Mixin exists for historical purposes only, and so that someone walking
+   * the types for Ember's arrays sees the same types as those which appear in
+   * the runtime hierarchy.
+   */
+  interface MutableEnumerable extends Enumerable {}
+  const MutableEnumerable: Mixin;
+  export default MutableEnumerable;
+}

package/types/preview/@ember/array/-private/native-array.d.ts

@@ -0,0 +1,23 @@
+declare module '@ember/array/-private/native-array' {
+  import Observable from '@ember/object/observable';
+  import MutableArray from '@ember/array/mutable';
+  import Mixin from '@ember/object/mixin';
+
+  // Get an alias to the global Array type to use in inner scope below.
+  type Array<T> = T[];
+
+  /**
+   * The NativeArray mixin contains the properties needed to make the native
+   * Array support Ember.MutableArray and all of its dependent APIs. Unless you
+   * have `EmberENV.EXTEND_PROTOTYPES` or `EmberENV.EXTEND_PROTOTYPES.Array` set to
+   * false, this will be applied automatically. Otherwise you can apply the mixin
+   * at anytime by calling `Ember.NativeArray.apply(Array.prototype)`.
+   */
+  interface NativeArray<T>
+    extends Omit<Array<T>, 'every' | 'filter' | 'find' | 'forEach' | 'map' | 'reduce' | 'slice'>,
+      Observable,
+      MutableArray<T> {}
+
+  const NativeArray: Mixin;
+  export default NativeArray;
+}

package/types/preview/@ember/array/index.d.ts

@@ -0,0 +1,243 @@
+declare module '@ember/array' {
+  import { MethodNamesOf, MethodParams, MethodReturns } from 'ember/-private/type-utils';
+  import Mixin from '@ember/object/mixin';
+  import Enumerable from '@ember/array/-private/enumerable';
+  import NativeArray from '@ember/array/-private/native-array';
+
+  /**
+   * This module implements Observer-friendly Array-like behavior. This mixin is picked up by the
+   * Array class as well as other controllers, etc. that want to appear to be arrays.
+   */
+  interface Array<T> extends Enumerable {
+    /**
+     * __Required.__ You must implement this method to apply this mixin.
+     */
+    length: number;
+    /**
+     * Returns the object at the given `index`. If the given `index` is negative
+     * or is greater or equal than the array length, returns `undefined`.
+     */
+    objectAt(idx: number): T | undefined;
+    /**
+     * This returns the objects at the specified indexes, using `objectAt`.
+     */
+    objectsAt(indexes: number[]): Array<T | undefined>;
+    /**
+     * Helper method returns the first object from a collection. This is usually
+     * used by bindings and other parts of the framework to extract a single
+     * object if the enumerable contains only one item.
+     */
+    firstObject: T | undefined;
+    /**
+     * Helper method returns the last object from a collection. If your enumerable
+     * contains only one object, this method should always return that object.
+     * If your enumerable is empty, this method should return `undefined`.
+     */
+    lastObject: T | undefined;
+    /**
+     * Returns a new array that is a slice of the receiver. This implementation
+     * uses the observable array methods to retrieve the objects for the new
+     * slice.
+     */
+    slice(beginIndex?: number, endIndex?: number): NativeArray<T>;
+    /**
+     * Returns the index of the given object's first occurrence.
+     * If no `startAt` argument is given, the starting location to
+     * search is 0. If it's negative, will count backward from
+     * the end of the array. Returns -1 if no match is found.
+     */
+    indexOf(searchElement: T, fromIndex?: number): number;
+    /**
+     * Returns the index of the given object's last occurrence.
+     * If no `startAt` argument is given, the search starts from
+     * the last position. If it's negative, will count backward
+     * from the end of the array. Returns -1 if no match is found.
+     */
+    lastIndexOf(searchElement: T, fromIndex?: number): number;
+    /**
+     * Iterates through the enumerable, calling the passed function on each
+     * item. This method corresponds to the `forEach()` method defined in
+     * JavaScript 1.6.
+     */
+    forEach<Target>(
+      callback: (this: Target, item: T, index: number, arr: this) => void,
+      target?: Target
+    ): this;
+    /**
+     * Alias for `mapBy`
+     */
+    getEach<K extends keyof T>(key: K): NativeArray<T[K]>;
+    /**
+     * Sets the value on the named property for each member. This is more
+     * ergonomic than using other methods defined on this helper. If the object
+     * implements Ember.Observable, the value will be changed to `set(),` otherwise
+     * it will be set directly. `null` objects are skipped.
+     */
+    setEach<K extends keyof T>(key: K, value: T[K]): void;
+    /**
+     * Maps all of the items in the enumeration to another value, returning
+     * a new array. This method corresponds to `map()` defined in JavaScript 1.6.
+     */
+    map<U, Target>(
+      callback: (this: Target, item: T, index: number, arr: this) => U,
+      target?: Target
+    ): NativeArray<U>;
+    /**
+     * Similar to map, this specialized function returns the value of the named
+     * property on all items in the enumeration.
+     */
+    mapBy<K extends keyof T>(key: K): NativeArray<T[K]>;
+    mapBy(key: string): NativeArray<unknown>;
+    /**
+     * Returns an array with all of the items in the enumeration that the passed
+     * function returns true for. This method corresponds to `filter()` defined in
+     * JavaScript 1.6.
+     */
+    filter<Target>(
+      callback: (this: Target, item: T, index: number, arr: this) => unknown,
+      target?: Target
+    ): NativeArray<T>;
+    /**
+     * Returns an array with all of the items in the enumeration where the passed
+     * function returns false. This method is the inverse of filter().
+     */
+    reject<Target>(
+      callback: (this: Target, item: T, index: number, arr: this) => unknown,
+      target?: Target
+    ): NativeArray<T>;
+    /**
+     * Returns an array with just the items with the matched property. You
+     * can pass an optional second argument with the target value. Otherwise
+     * this will match any property that evaluates to `true`.
+     */
+    filterBy<K extends keyof T>(key: K, value?: T[K]): NativeArray<T>;
+    /**
+     * Returns an array with the items that do not have truthy values for
+     * key.  You can pass an optional second argument with the target value.  Otherwise
+     * this will match any property that evaluates to false.
+     */
+    rejectBy<K extends keyof T>(key: K, value?: T[K]): NativeArray<T>;
+    /**
+     * Returns the first item in the array for which the callback returns true.
+     * This method works similar to the `filter()` method defined in JavaScript 1.6
+     * except that it will stop working on the array once a match is found.
+     */
+    find<S extends T, Target = void>(
+      predicate: (this: void, value: T, index: number, obj: T[]) => value is S,
+      thisArg?: Target
+    ): S | undefined;
+    find<Target = void>(
+      callback: (this: Target, item: T, index: number, arr: this) => unknown,
+      target?: Target
+    ): T | undefined;
+    /**
+     * Returns the first item with a property matching the passed value. You
+     * can pass an optional second argument with the target value. Otherwise
+     * this will match any property that evaluates to `true`.
+     */
+    findBy<K extends keyof T>(key: K, value?: T[K]): T | undefined;
+    /**
+     * Returns `true` if the passed function returns true for every item in the
+     * enumeration. This corresponds with the `every()` method in JavaScript 1.6.
+     */
+    every<Target = void>(
+      callback: (this: Target, item: T, index: number, arr: this) => unknown,
+      target?: Target
+    ): boolean;
+    /**
+     * Returns `true` if the passed property resolves to the value of the second
+     * argument for all items in the enumerable. This method is often simpler/faster
+     * than using a callback.
+     */
+    isEvery<K extends keyof T>(key: K, value?: T[K]): boolean;
+    /**
+     * Returns `true` if the passed function returns true for any item in the
+     * enumeration.
+     */
+    any<Target = void>(
+      callback: (this: Target, item: T, index: number, arr: this) => unknown,
+      target?: Target
+    ): boolean;
+    /**
+     * Returns `true` if the passed property resolves to the value of the second
+     * argument for any item in the enumerable. This method is often simpler/faster
+     * than using a callback.
+     */
+    isAny<K extends keyof T>(key: K, value?: T[K]): boolean;
+    /**
+     * This will combine the values of the enumerator into a single value. It
+     * is a useful way to collect a summary value from an enumeration. This
+     * corresponds to the `reduce()` method defined in JavaScript 1.8.
+     */
+    reduce: T[]['reduce'];
+    /**
+     * Invokes the named method on every object in the receiver that
+     * implements it. This method corresponds to the implementation in
+     * Prototype 1.6.
+     */
+    invoke<M extends MethodNamesOf<T>>(
+      methodName: M,
+      ...args: MethodParams<T, M>
+    ): Array<MethodReturns<T, M>>;
+    /**
+     * Simply converts the enumerable into a genuine array. The order is not
+     * guaranteed. Corresponds to the method implemented by Prototype.
+     */
+    toArray(): T[];
+    /**
+     * Returns a copy of the array with all `null` and `undefined` elements removed.
+     */
+    compact(): NativeArray<NonNullable<T>>;
+    /**
+     * Returns `true` if the passed object can be found in the enumerable.
+     */
+    includes(searchElement: T, fromIndex?: number): boolean;
+    /**
+     * Converts the enumerable into an array and sorts by the keys
+     * specified in the argument.
+     */
+    sortBy(...properties: string[]): NativeArray<T>;
+    /**
+     * Returns a new enumerable that excludes the passed value. The default
+     * implementation returns an array regardless of the receiver type.
+     * If the receiver does not contain the value it returns the original enumerable.
+     */
+    without(value: T): NativeArray<T>;
+    /**
+     * Returns a new enumerable that contains only unique values. The default
+     * implementation returns an array regardless of the receiver type.
+     */
+    uniq(): NativeArray<T>;
+    /**
+     * Returns a new enumerable that contains only items containing a unique property value.
+     * The default implementation returns an array regardless of the receiver type.
+     */
+    uniqBy(property: string): NativeArray<T>;
+    uniqBy(callback: (value: T) => unknown): NativeArray<T>;
+    /**
+     * This is the handler for the special array content property. If you get
+     * this property, it will return this. If you set this property to a new
+     * array, it will replace the current content.
+     */
+    get '[]'(): NativeArray<T>;
+    set '[]'(newValue: NativeArray<T>);
+  }
+  // Ember.Array rather than Array because the `array-type` lint rule doesn't realize the global is shadowed
+  const Array: Mixin;
+  export default Array;
+
+  /**
+   * Creates an `Ember.NativeArray` from an Array like object.
+   * Does not modify the original object's contents. Ember.A is not needed if
+   * `EmberENV.EXTEND_PROTOTYPES` is `true` (the default value). However,
+   * it is recommended that you use Ember.A when creating addons for
+   * ember or when you can not guarantee that `EmberENV.EXTEND_PROTOTYPES`
+   * will be `true`.
+   */
+  export function A<T>(arr?: T[]): NativeArray<T>;
+
+  /**
+   * Returns true if the passed object is an array or Array-like.
+   */
+  export function isArray(obj: unknown): obj is ArrayLike<unknown>;
+}