Logo for jsDocs.io

ember-data

  • Version 5.9.1
  • Published
  • 389 kB
  • 19 dependencies
  • MIT license

Install

npm i ember-data
yarn add ember-data
pnpm add ember-data

Overview

(Legacy) The lightweight reactive data library for Ember applications

Index

Variables

Interfaces

Namespaces

Variables

variable DS

const DS: DS;

    Interfaces

    interface DS

    interface DS extends Namespace {}

      property name

      name: string;

        property VERSION

        VERSION: string;

          Namespaces

          namespace ember-data

          module 'ember-data' {}

            namespace ember-data/-private

            module 'ember-data/-private' {}

              variable PromiseArray

              const PromiseArray: any;

                variable PromiseObject

                const PromiseObject: any;

                  namespace ember-data/-private/core

                  module 'ember-data/-private/core' {}

                    namespace ember-data/adapter

                    module 'ember-data/adapter' {}

                      namespace ember-data/adapters/errors

                      module 'ember-data/adapters/errors' {}

                        namespace ember-data/adapters/json-api

                        module 'ember-data/adapters/json-api' {}

                          namespace ember-data/adapters/rest

                          module 'ember-data/adapters/rest' {}

                            namespace ember-data/attr

                            module 'ember-data/attr' {}

                              namespace ember-data/core-BbXeQ0i8

                              module 'ember-data/core-BbXeQ0i8' {}

                                variable t

                                const t: DS;

                                  interface t

                                  interface DS extends Namespace {}

                                    property name

                                    name: string;

                                      property VERSION

                                      VERSION: string;

                                        namespace ember-data/model

                                        module 'ember-data/model' {}

                                          namespace ember-data/relationships

                                          module 'ember-data/relationships' {}

                                            namespace ember-data/serializer

                                            module 'ember-data/serializer' {}

                                              namespace ember-data/serializers/embedded-records-mixin

                                              module 'ember-data/serializers/embedded-records-mixin' {}

                                                namespace ember-data/serializers/json

                                                module 'ember-data/serializers/json' {}

                                                  namespace ember-data/serializers/json-api

                                                  module 'ember-data/serializers/json-api' {}

                                                    namespace ember-data/serializers/rest

                                                    module 'ember-data/serializers/rest' {}

                                                      namespace ember-data/setup-container

                                                      module 'ember-data/setup-container' {}

                                                        function setupContainer

                                                        setupContainer: (application: Application) => void;

                                                          namespace ember-data/store

                                                          module 'ember-data/store' {}

                                                            namespace ember-data/store-D_zJZti4

                                                            module 'ember-data/store-D_zJZti4' {}

                                                              class t

                                                              class Store extends BaseStore {}

                                                                constructor

                                                                constructor(args?: Record<string, unknown>);

                                                                  property normalize

                                                                  normalize: (
                                                                      ...args: Parameters<typeof normalize>
                                                                  ) => ReturnType<typeof normalize>;

                                                                    property pushPayload

                                                                    pushPayload: (
                                                                        ...args: Parameters<typeof pushPayload>
                                                                    ) => ReturnType<typeof pushPayload>;

                                                                      property serializeRecord

                                                                      serializeRecord: (
                                                                          ...args: Parameters<typeof serializeRecord>
                                                                      ) => ReturnType<typeof serializeRecord>;

                                                                        property serializerFor

                                                                        serializerFor: (
                                                                            ...args: Parameters<typeof serializerFor>
                                                                        ) => ReturnType<typeof serializerFor>;

                                                                          method adapterFor

                                                                          adapterFor: {
                                                                              (this: Store, modelName: string): MinimumAdapterInterface;
                                                                              (this: Store, modelName: string, _allowMissing: true): any;
                                                                          };

                                                                            method createCache

                                                                            createCache: (storeWrapper: CacheCapabilitiesManager) => Cache;

                                                                              method createSchemaService

                                                                              createSchemaService: () => SchemaService;

                                                                                method destroy

                                                                                destroy: () => void;

                                                                                  method instantiateRecord

                                                                                  instantiateRecord: (
                                                                                      key: ResourceKey,
                                                                                      createRecordArgs: Record<string, unknown>
                                                                                  ) => Model;

                                                                                    method modelFor

                                                                                    modelFor: {
                                                                                        <T>(type: TypeFromInstance<T>): ModelSchema<T>;
                                                                                        (type: string): ModelSchema;
                                                                                    };

                                                                                      method teardownRecord

                                                                                      teardownRecord: (record: unknown) => void;

                                                                                        namespace ember-data/test-support

                                                                                        module 'ember-data/test-support' {}

                                                                                          function render

                                                                                          render: (template: object) => Promise<void>;

                                                                                            namespace ember-data/transform

                                                                                            module 'ember-data/transform' {}

                                                                                              namespace ember-data/version

                                                                                              module 'ember-data/version' {}

                                                                                                variable _default

                                                                                                const _default: string;

                                                                                                  Package Files (24)

                                                                                                  Dependencies (19)

                                                                                                  Dev Dependencies (13)

                                                                                                  Peer Dependencies (3)

                                                                                                  Badge

                                                                                                  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/ember-data.

                                                                                                  • Markdown
                                                                                                    [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/ember-data)
                                                                                                  • HTML
                                                                                                    <a href="https://www.jsdocs.io/package/ember-data"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>