Logo for jsDocs.io

ember-data

  • Version 5.8.0
  • Published
  • 324 kB
  • 19 dependencies
  • MIT license

Install

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

Overview

The lightweight reactive data library for JavaScript applications

Index

Namespaces

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' {}

            variable DS

            const DS: DS;

              interface DS

              interface DS extends Namespace {}

                property name

                name: string;

                  property VERSION

                  VERSION: string;

                    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/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' {}

                                                  class Store

                                                  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' {}

                                                                                    Package Files (20)

                                                                                    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>