• Version 4.0.11
  • Published
  • 22.8 kB
  • 17 dependencies
  • MIT license


npm i @types/ember
yarn add @types/ember
pnpm add @types/ember


TypeScript definitions for ember




namespace Ember

namespace Ember {}

    variable A

    const A: any;

      variable ActionHandler

      const ActionHandler: any;

        variable addListener

        const addListener: any;

          variable addObserver

          const addObserver: any;

            variable Array

            const Array: any;

              variable assert

              const assert: any;

                variable assign

                const assign: any;
                • Copy properties from a source object to a target object.


                  until v5.0. You should replace any calls to Ember.assign with Object.assign or use the object spread operator.

                variable cacheFor

                const cacheFor: any;

                  variable Comparable

                  const Comparable: EmberMixin<Comparable>;

                    variable compare

                    const compare: any;

                      variable computed

                      const computed: any;

                        variable debug

                        const debug: any;

                          variable Debug

                          const Debug: { registerDeprecationHandler: any; registerWarnHandler: any };

                            variable defineProperty

                            const defineProperty: any;

                              variable deprecate

                              const deprecate: any;

                                variable Enumerable

                                const Enumerable: any;

                                  variable Error

                                  const Error: any;
                                  • A subclass of the JavaScript Error object for use in Ember.

                                  variable Evented

                                  const Evented: any;

                                    variable expandProperties

                                    const expandProperties: any;

                                      variable get

                                      const get: any;

                                        variable getOwner

                                        const getOwner: any;

                                          variable getProperties

                                          const getProperties: any;

                                            variable guidFor

                                            const guidFor: any;

                                              variable htmlSafe

                                              const htmlSafe: any;

                                                variable isArray

                                                const isArray: any;

                                                  variable isBlank

                                                  const isBlank: any;

                                                    variable isEmpty

                                                    const isEmpty: any;

                                                      variable isEqual

                                                      const isEqual: any;
                                                      • Creates a shallow copy of the passed object. A deep copy of the object is returned if the optional deep argument is true.

                                                      variable isHTMLSafe

                                                      const isHTMLSafe: any;

                                                        variable isNone

                                                        const isNone: any;

                                                          variable isPresent

                                                          const isPresent: any;

                                                            variable MutableArray

                                                            const MutableArray: any;

                                                              variable MutableEnumerable

                                                              const MutableEnumerable: any;

                                                                variable NativeArray

                                                                const NativeArray: any;

                                                                  variable notifyPropertyChange

                                                                  const notifyPropertyChange: any;

                                                                    variable Observable

                                                                    const Observable: any;

                                                                      variable observer

                                                                      const observer: any;

                                                                        variable on

                                                                        const on: any;

                                                                          variable onerror

                                                                          let onerror: (error: Error) => void;
                                                                          • 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.

                                                                          variable platform

                                                                          const platform: { defineProperty: boolean; hasPropertyAccessors: boolean };

                                                                            variable PromiseProxyMixin

                                                                            const PromiseProxyMixin: any;

                                                                              variable removeListener

                                                                              const removeListener: any;

                                                                                variable removeObserver

                                                                                const removeObserver: any;

                                                                                  variable RSVP

                                                                                  const RSVP: any;

                                                                                    variable run

                                                                                    const run: Run;

                                                                                      variable runInDebug

                                                                                      const runInDebug: any;

                                                                                        variable sendEvent

                                                                                        const sendEvent: any;

                                                                                          variable set

                                                                                          const set: any;

                                                                                            variable setOwner

                                                                                            const setOwner: any;

                                                                                              variable setProperties

                                                                                              const setProperties: any;

                                                                                                variable testing

                                                                                                const testing: boolean;
                                                                                                • This property indicates whether or not this application is currently in testing mode. This is set when setupForTesting is called on the current application.

                                                                                                variable trySet

                                                                                                const trySet: any;

                                                                                                  variable typeOf

                                                                                                  const typeOf: any;

                                                                                                    variable VERSION

                                                                                                    const VERSION: string;
                                                                                                    • The semantic version

                                                                                                    variable ViewTargetActionSupport

                                                                                                    const ViewTargetActionSupport: Mixin<ViewTargetActionSupport, EmberObjectNs.default>;

                                                                                                      variable ViewUtils

                                                                                                      const ViewUtils: { isSimpleClick(event: Event): boolean };

                                                                                                        variable warn

                                                                                                        const warn: any;

                                                                                                          function getEngineParent

                                                                                                          getEngineParent: (engine: EngineInstance) => EngineInstance;
                                                                                                          • getEngineParent retrieves an engine instance's parent instance.

                                                                                                          class Application

                                                                                                          class Application extends EmberApplicationNs.default {}

                                                                                                            class ApplicationInstance

                                                                                                            class ApplicationInstance extends EmberApplicationInstanceNs.default {}

                                                                                                              class ArrayProxy

                                                                                                              class ArrayProxy<T> extends EmberArrayProxy<T> {}

                                                                                                                class Component

                                                                                                                class Component extends EmberComponent {}

                                                                                                                  class ComputedProperty

                                                                                                                  class ComputedProperty<Get, Set = Get> extends EmberObjectComputedNs.default<
                                                                                                                  > {}

                                                                                                                    class Container

                                                                                                                    class Container {}
                                                                                                                    • A container used to instantiate and cache objects.

                                                                                                                    method factoryFor

                                                                                                                    factoryFor: (fullName: string, options?: {}) => unknown;
                                                                                                                    • Given a fullName, return the corresponding factory. The consumer of the factory is responsible for the destruction of any factory instances, as there is no way for the container to ensure instances are destroyed when it itself is destroyed.

                                                                                                                    class ContainerDebugAdapter

                                                                                                                    class ContainerDebugAdapter extends _ContainerDebugAdapter {}

                                                                                                                      class Controller

                                                                                                                      class Controller extends EmberControllerNs.default {}

                                                                                                                        class CoreObject

                                                                                                                        class CoreObject extends EmberCoreObject {}

                                                                                                                          class DataAdapter

                                                                                                                          class DataAdapter extends EmberDataAdapter {}

                                                                                                                            class Engine

                                                                                                                            class Engine extends EmberEngineNs.default {}

                                                                                                                              class EngineInstance

                                                                                                                              class EngineInstance extends EmberEngineInstanceNs.default {}

                                                                                                                                class EventDispatcher

                                                                                                                                class EventDispatcher extends EmberEventDispatcher {}

                                                                                                                                  class HashLocation

                                                                                                                                  class HashLocation extends EmberRoutingHashLocation {}

                                                                                                                                    class Helper

                                                                                                                                    class Helper extends EmberHelper {}

                                                                                                                                      class HistoryLocation

                                                                                                                                      class HistoryLocation extends EmberRoutingHistoryLocation {}

                                                                                                                                        class Mixin

                                                                                                                                        class Mixin<T, Base = EmberObjectNs.default> extends EmberMixin<T, Base> {}

                                                                                                                                          class Namespace

                                                                                                                                          class Namespace extends Object {}
                                                                                                                                          • A Namespace is an object usually used to contain other objects or methods such as an application or framework. Create a namespace anytime you want to define one of these new containers.

                                                                                                                                          class NoneLocation

                                                                                                                                          class NoneLocation extends EmberRoutingNoneLocation {}

                                                                                                                                            class Object

                                                                                                                                            class Object extends EmberObjectNs.default {}

                                                                                                                                              class ObjectProxy

                                                                                                                                              class ObjectProxy extends EmberObjectProxyNs.default {}

                                                                                                                                                class Registry

                                                                                                                                                class Registry extends EmberRegistry {}

                                                                                                                                                  class Route

                                                                                                                                                  class Route extends EmberRoutingRoute {}

                                                                                                                                                    class Router

                                                                                                                                                    class Router extends EmberRoutingRouter {}

                                                                                                                                                      class Service

                                                                                                                                                      class Service extends Object {}

                                                                                                                                                        interface ArrayPrototypeExtensions

                                                                                                                                                        interface ArrayPrototypeExtensions<T> extends EmberArrayProtoExtensions<T> {}

                                                                                                                                                          interface Comparable

                                                                                                                                                          interface Comparable {}
                                                                                                                                                          • Implements some standard methods for comparing objects. Add this mixin to any class you create that can compare its instances.

                                                                                                                                                          method compare

                                                                                                                                                          compare: (a: unknown, b: unknown) => number;

                                                                                                                                                            interface Run

                                                                                                                                                            interface Run extends RunFn, EmberRunloop {}

                                                                                                                                                              interface ViewTargetActionSupport

                                                                                                                                                              interface ViewTargetActionSupport {}

                                                                                                                                                                property actionContext

                                                                                                                                                                actionContext: unknown;

                                                                                                                                                                  property target

                                                                                                                                                                  target: unknown;

                                                                                                                                                                    type Array

                                                                                                                                                                    type Array<T> = EmberArray<T>;

                                                                                                                                                                      type EmberRunloop

                                                                                                                                                                      type EmberRunloop = typeof EmberRunloopNs;

                                                                                                                                                                        type Enumerable

                                                                                                                                                                        type Enumerable<T> = EmberEnumerable<T>;

                                                                                                                                                                          type MutableArray

                                                                                                                                                                          type MutableArray<T> = EmberMutableArray<T>;

                                                                                                                                                                            type MutableEnumerable

                                                                                                                                                                            type MutableEnumerable<T> = EmberMutableEnumerable<T>;

                                                                                                                                                                              type NativeArray

                                                                                                                                                                              type NativeArray<T> = EmberNativeArray<T>;

                                                                                                                                                                                type RunFn

                                                                                                                                                                                type RunFn = EmberRunloop['run'];

                                                                                                                                                                                  namespace Ember.ENV

                                                                                                                                                                                  namespace Ember.ENV {}

                                                                                                                                                                                    variable EXTEND_PROTOTYPES

                                                                                                                                                                                    const EXTEND_PROTOTYPES: { Array: boolean; Function: boolean; String: boolean };

                                                                                                                                                                                      variable LOG_BINDINGS

                                                                                                                                                                                      const LOG_BINDINGS: boolean;

                                                                                                                                                                                        variable LOG_STACKTRACE_ON_DEPRECATION

                                                                                                                                                                                        const LOG_STACKTRACE_ON_DEPRECATION: boolean;

                                                                                                                                                                                          variable LOG_VERSION

                                                                                                                                                                                          const LOG_VERSION: boolean;

                                                                                                                                                                                            variable MODEL_FACTORY_INJECTIONS

                                                                                                                                                                                            const MODEL_FACTORY_INJECTIONS: boolean;

                                                                                                                                                                                              variable RAISE_ON_DEPRECATION

                                                                                                                                                                                              const RAISE_ON_DEPRECATION: boolean;

                                                                                                                                                                                                namespace Ember.Handlebars

                                                                                                                                                                                                namespace Ember.Handlebars {}

                                                                                                                                                                                                  function compile

                                                                                                                                                                                                  compile: {
                                                                                                                                                                                                  (string: string): (...args: any[]) => any;
                                                                                                                                                                                                  (environment: any, options?: any, context?: any, asObject?: any): any;

                                                                                                                                                                                                    function createFrame

                                                                                                                                                                                                    createFrame: (objec: any) => any;

                                                                                                                                                                                                      function Exception

                                                                                                                                                                                                      Exception: (message: string) => void;

                                                                                                                                                                                                        function log

                                                                                                                                                                                                        log: (level: string, str: string) => void;

                                                                                                                                                                                                          function parse

                                                                                                                                                                                                          parse: (string: string) => any;

                                                                                                                                                                                                            function precompile

                                                                                                                                                                                                            precompile: (string: string, options: any) => void;

                                                                                                                                                                                                              function print

                                                                                                                                                                                                              print: (ast: any) => void;

                                                                                                                                                                                                                function registerHelper

                                                                                                                                                                                                                registerHelper: (name: string, helper: any) => void;

                                                                                                                                                                                                                  function registerPartial

                                                                                                                                                                                                                  registerPartial: (name: string, str: any) => void;

                                                                                                                                                                                                                    class Compiler

                                                                                                                                                                                                                    class Compiler {}

                                                                                                                                                                                                                      class JavaScriptCompiler

                                                                                                                                                                                                                      class JavaScriptCompiler {}

                                                                                                                                                                                                                        class SafeString

                                                                                                                                                                                                                        class SafeString extends EmberTemplateHandlebarsNs.SafeString {}

                                                                                                                                                                                                                          namespace Ember.inject

                                                                                                                                                                                                                          namespace Ember.inject {}
                                                                                                                                                                                                                          • Namespace for injection helper methods.

                                                                                                                                                                                                                          variable service

                                                                                                                                                                                                                          const service: any;

                                                                                                                                                                                                                            function controller

                                                                                                                                                                                                                            controller: {
                                                                                                                                                                                                                            (): ComputedProperty<Controller>;
                                                                                                                                                                                                                            <K extends string | number | symbol>(name: K): ComputedProperty<
                                                                                                                                                                                                                            • Creates a property that lazily looks up another controller in the container. Can only be used when defining another controller.

                                                                                                                                                                                                                            namespace Ember.RSVP

                                                                                                                                                                                                                            namespace Ember.RSVP {}

                                                                                                                                                                                                                              type Promise

                                                                                                                                                                                                                              type Promise<T> = Rsvp.Promise<T>;

                                                                                                                                                                                                                                namespace Ember.String

                                                                                                                                                                                                                                namespace Ember.String {}

                                                                                                                                                                                                                                  variable camelize

                                                                                                                                                                                                                                  const camelize: any;

                                                                                                                                                                                                                                    variable capitalize

                                                                                                                                                                                                                                    const capitalize: any;

                                                                                                                                                                                                                                      variable classify

                                                                                                                                                                                                                                      const classify: any;

                                                                                                                                                                                                                                        variable dasherize

                                                                                                                                                                                                                                        const dasherize: any;

                                                                                                                                                                                                                                          variable decamelize

                                                                                                                                                                                                                                          const decamelize: any;

                                                                                                                                                                                                                                            variable htmlSafe

                                                                                                                                                                                                                                            const htmlSafe: any;

                                                                                                                                                                                                                                              variable isHTMLSafe

                                                                                                                                                                                                                                              const isHTMLSafe: any;

                                                                                                                                                                                                                                                variable underscore

                                                                                                                                                                                                                                                const underscore: any;

                                                                                                                                                                                                                                                  variable w

                                                                                                                                                                                                                                                  const w: any;

                                                                                                                                                                                                                                                    function fmt

                                                                                                                                                                                                                                                    fmt: (...args: string[]) => string;

                                                                                                                                                                                                                                                      namespace Ember.Template

                                                                                                                                                                                                                                                      namespace Ember.Template {}

                                                                                                                                                                                                                                                        variable htmlSafe

                                                                                                                                                                                                                                                        const htmlSafe: any;

                                                                                                                                                                                                                                                          variable isHTMLSafe

                                                                                                                                                                                                                                                          const isHTMLSafe: any;

                                                                                                                                                                                                                                                            namespace Ember.Test

                                                                                                                                                                                                                                                            namespace Ember.Test {}
                                                                                                                                                                                                                                                            • This is a container for an assortment of testing related functionality

                                                                                                                                                                                                                                                            variable adapter

                                                                                                                                                                                                                                                            const adapter: EmberTestAdapter;
                                                                                                                                                                                                                                                            • Used to allow ember-testing to communicate with a specific testing framework.

                                                                                                                                                                                                                                                            variable registerAsyncHelper

                                                                                                                                                                                                                                                            const registerAsyncHelper: any;

                                                                                                                                                                                                                                                              variable registerHelper

                                                                                                                                                                                                                                                              const registerHelper: any;

                                                                                                                                                                                                                                                                variable registerWaiter

                                                                                                                                                                                                                                                                const registerWaiter: any;

                                                                                                                                                                                                                                                                  variable unregisterHelper

                                                                                                                                                                                                                                                                  const unregisterHelper: any;

                                                                                                                                                                                                                                                                    variable unregisterWaiter

                                                                                                                                                                                                                                                                    const unregisterWaiter: any;

                                                                                                                                                                                                                                                                      function checkWaiters

                                                                                                                                                                                                                                                                      checkWaiters: () => boolean;
                                                                                                                                                                                                                                                                      • Iterates through each registered test waiter, and invokes its callback. If any waiter returns false, this method will return true indicating that the waiters have not settled yet.

                                                                                                                                                                                                                                                                      function onInjectHelpers

                                                                                                                                                                                                                                                                      onInjectHelpers: (callback: (app: Application) => void) => void;
                                                                                                                                                                                                                                                                      • Used to register callbacks to be fired whenever App.injectTestHelpers is called.

                                                                                                                                                                                                                                                                      function promise

                                                                                                                                                                                                                                                                      promise: <T>(
                                                                                                                                                                                                                                                                      resolver: (
                                                                                                                                                                                                                                                                      resolve: (value?: T | PromiseLike<T>) => void,
                                                                                                                                                                                                                                                                      reject: (reason?: unknown) => void
                                                                                                                                                                                                                                                                      ) => void,
                                                                                                                                                                                                                                                                      label?: string
                                                                                                                                                                                                                                                                      ) => Promise<T>;
                                                                                                                                                                                                                                                                      • This returns a thenable tailored for testing. It catches failed onSuccess callbacks and invokes the Ember.Test.adapter.exception callback in the last chained then.

                                                                                                                                                                                                                                                                      function resolve

                                                                                                                                                                                                                                                                      resolve: <T>(value?: T | PromiseLike<T>, label?: string) => Promise<T>;
                                                                                                                                                                                                                                                                      • Replacement for Ember.RSVP.resolve The only difference is this uses an instance of Ember.Test.Promise

                                                                                                                                                                                                                                                                      class Adapter

                                                                                                                                                                                                                                                                      class Adapter extends EmberTestAdapter {}

                                                                                                                                                                                                                                                                        class Promise

                                                                                                                                                                                                                                                                        class Promise<T> extends Rsvp.Promise<T> {}


                                                                                                                                                                                                                                                                          executor: (
                                                                                                                                                                                                                                                                          resolve: (value?: T | PromiseLike<T>) => void,
                                                                                                                                                                                                                                                                          reject: (reason?: unknown) => void
                                                                                                                                                                                                                                                                          ) => void

                                                                                                                                                                                                                                                                            class QUnitAdapter

                                                                                                                                                                                                                                                                            class QUnitAdapter extends EmberTestAdapter {}
                                                                                                                                                                                                                                                                            • This class implements the methods defined by Ember.Test.Adapter for the QUnit testing framework.

                                                                                                                                                                                                                                                                            Package Files (1)

                                                                                                                                                                                                                                                                            Dependencies (17)

                                                                                                                                                                                                                                                                            Dev Dependencies (0)

                                                                                                                                                                                                                                                                            No dev dependencies.

                                                                                                                                                                                                                                                                            Peer Dependencies (0)

                                                                                                                                                                                                                                                                            No peer dependencies.


                                                                                                                                                                                                                                                                            To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                            You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/ember.

                                                                                                                                                                                                                                                                            • Markdown
                                                                                                                                                                                                                                                                            • HTML
                                                                                                                                                                                                                                                                              <a href="https://www.jsdocs.io/package/@types/ember"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>