@ember-data/store 5.4.0-alpha.30 → 5.4.0-alpha.31

package/unstable-preview-types/-private/legacy-model-support/record-reference.d.ts

@@ -0,0 +1,177 @@
+import type { StableRecordIdentifier } from '@warp-drive/core-types/identifier';
+/**
+  @module @ember-data/store
+*/
+import type { SingleResourceDocument } from '@warp-drive/core-types/spec/raw';
+import type { OpaqueRecordInstance } from '../../-types/q/record-instance';
+import type Store from '../store-service';
+/**
+  @module @ember-data/store
+*/
+/**
+   A `RecordReference` is a low-level API that allows users and
+   addon authors to perform meta-operations on a record.
+
+   @class RecordReference
+   @public
+*/
+export default class RecordReference {
+    store: Store;
+    ___token: object;
+    ___identifier: StableRecordIdentifier;
+    _ref: number;
+    constructor(store: Store, identifier: StableRecordIdentifier);
+    destroy(): void;
+    get type(): string;
+    /**
+       The `id` of the record that this reference refers to.
+  
+       Together, the `type` and `id` properties form a composite key for
+       the identity map.
+  
+       Example
+  
+       ```javascript
+       let userRef = store.getReference('user', 1);
+  
+       userRef.id(); // '1'
+       ```
+  
+       @method id
+      @public
+       @return {String} The id of the record.
+    */
+    id(): string | null;
+    /**
+       The `identifier` of the record that this reference refers to.
+  
+       Together, the `type` and `id` properties form a composite key for
+       the identity map.
+  
+       Example
+  
+       ```javascript
+       let userRef = store.getReference('user', 1);
+  
+       userRef.identifier(); // '1'
+       ```
+  
+       @method identifier
+      @public
+       @return {String} The identifier of the record.
+    */
+    identifier(): StableRecordIdentifier;
+    /**
+       How the reference will be looked up when it is loaded. Currently
+       this always returns `identity` to signify that a record will be
+       loaded by its `type` and `id`.
+  
+       Example
+  
+       ```javascript
+       const userRef = store.getReference('user', 1);
+  
+       userRef.remoteType(); // 'identity'
+       ```
+  
+       @method remoteType
+       @public
+       @return {String} 'identity'
+    */
+    remoteType(): 'identity';
+    /**
+      This API allows you to provide a reference with new data. The
+      simplest usage of this API is similar to `store.push`: you provide a
+      normalized hash of data and the object represented by the reference
+      will update.
+  
+      If you pass a promise to `push`, Ember Data will not ask the adapter
+      for the data if another attempt to fetch it is made in the
+      interim. When the promise resolves, the underlying object is updated
+      with the new data, and the promise returned by *this function* is resolved
+      with that object.
+  
+      For example, `recordReference.push(promise)` will be resolved with a
+      record.
+  
+       Example
+  
+       ```javascript
+       let userRef = store.getReference('user', 1);
+  
+       // provide data for reference
+       userRef.push({
+         data: {
+           id: "1",
+           type: "user",
+           attributes: {
+             username: "@user"
+           }
+         }
+       }).then(function(user) {
+         userRef.value() === user;
+       });
+       ```
+  
+      @method push
+      @public
+      @param objectOrPromise a JSON:API ResourceDocument or a promise resolving to one
+      @return a promise for the value (record or relationship)
+    */
+    push(objectOrPromise: SingleResourceDocument | Promise<SingleResourceDocument>): Promise<OpaqueRecordInstance>;
+    /**
+      If the entity referred to by the reference is already loaded, it is
+      present as `reference.value`. Otherwise the value returned by this function
+      is `null`.
+  
+       Example
+  
+       ```javascript
+       let userRef = store.getReference('user', 1);
+  
+       userRef.value(); // user
+       ```
+  
+       @method value
+      @public
+       @return {Model} the record for this RecordReference
+    */
+    value(): OpaqueRecordInstance | null;
+    /**
+       Triggers a fetch for the backing entity based on its `remoteType`
+       (see `remoteType` definitions per reference type).
+  
+       Example
+  
+       ```javascript
+       let userRef = store.getReference('user', 1);
+  
+       // load user (via store.find)
+       userRef.load().then(...)
+       ```
+  
+       @method load
+      @public
+       @return {Promise<record>} the record for this RecordReference
+    */
+    load(): Promise<unknown>;
+    /**
+       Reloads the record if it is already loaded. If the record is not
+       loaded it will load the record via `store.findRecord`
+  
+       Example
+  
+       ```javascript
+       let userRef = store.getReference('user', 1);
+  
+       // or trigger a reload
+       userRef.reload().then(...)
+       ```
+  
+       @method reload
+      @public
+       @return {Promise<record>} the record for this RecordReference
+    */
+    reload(): Promise<unknown>;
+}
+//# sourceMappingURL=record-reference.d.ts.map

package/unstable-preview-types/-private/legacy-model-support/record-reference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"record-reference.d.ts","sourceRoot":"","sources":["../../../src/-private/legacy-model-support/record-reference.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,mCAAmC,CAAC;AAChF;;EAEE;AACF,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAE9E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AAE3E,OAAO,KAAK,KAAK,MAAM,kBAAkB,CAAC;AAE1C;;EAEE;AAEF;;;;;;EAME;AACF,MAAM,CAAC,OAAO,OAAO,eAAe;IAC1B,KAAK,EAAE,KAAK,CAAC;IAErB,QAAQ,EAAG,MAAM,CAAC;IAClB,aAAa,EAAE,sBAAsB,CAAC;IAE9B,IAAI,EAAE,MAAM,CAAC;gBAET,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,sBAAsB;IAa5D,OAAO;IAIP,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;;;;;;;;;;;;;;;MAiBE;IACF,EAAE;IAKF;;;;;;;;;;;;;;;;;MAiBE;IACF,UAAU,IAAI,sBAAsB;IAIpC;;;;;;;;;;;;;;;;MAgBE;IACF,UAAU,IAAI,UAAU;IAIxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAsCE;IACF,IAAI,CAAC,eAAe,EAAE,sBAAsB,GAAG,OAAO,CAAC,sBAAsB,CAAC,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAO9G;;;;;;;;;;;;;;;;MAgBE;IACF,KAAK,IAAI,oBAAoB,GAAG,IAAI;IAIpC;;;;;;;;;;;;;;;;MAgBE;IACF,IAAI;IAQJ;;;;;;;;;;;;;;;;MAgBE;IACF,MAAM;CAOP"}

package/unstable-preview-types/-private/legacy-model-support/shim-model-class.d.ts

@@ -0,0 +1,17 @@
+import type { TypedRecordInstance, TypeFromInstance } from '@warp-drive/core-types/record';
+import type { AttributeSchema, RelationshipSchema } from '@warp-drive/core-types/schema';
+import type { KeyOrString, ModelSchema } from '../../-types/q/ds-model';
+import type Store from '../store-service';
+export declare function getShimClass<T>(store: Store, modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string): ShimModelClass<T>;
+export default class ShimModelClass<T = unknown> implements ModelSchema<T> {
+    __store: Store;
+    modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string;
+    constructor(store: Store, modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string);
+    get fields(): Map<KeyOrString<T>, 'attribute' | 'belongsTo' | 'hasMany'>;
+    get attributes(): Map<KeyOrString<T>, AttributeSchema>;
+    get relationshipsByName(): Map<KeyOrString<T>, RelationshipSchema>;
+    eachAttribute<K extends KeyOrString<T>>(callback: (key: K, attribute: AttributeSchema) => void, binding?: T): void;
+    eachRelationship<K extends KeyOrString<T>>(callback: (key: K, relationship: RelationshipSchema) => void, binding?: T): void;
+    eachTransformedAttribute<K extends KeyOrString<T>>(callback: (key: K, type: string | null) => void, binding?: T): void;
+}
+//# sourceMappingURL=shim-model-class.d.ts.map

package/unstable-preview-types/-private/legacy-model-support/shim-model-class.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shim-model-class.d.ts","sourceRoot":"","sources":["../../../src/-private/legacy-model-support/shim-model-class.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAC3F,OAAO,KAAK,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAEzF,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACxE,OAAO,KAAK,KAAK,MAAM,kBAAkB,CAAC;AAM1C,wBAAgB,YAAY,CAAC,CAAC,EAC5B,KAAK,EAAE,KAAK,EACZ,SAAS,EAAE,CAAC,SAAS,mBAAmB,GAAG,gBAAgB,CAAC,CAAC,CAAC,GAAG,MAAM,GACtE,cAAc,CAAC,CAAC,CAAC,CAcnB;AAaD,MAAM,CAAC,OAAO,OAAO,cAAc,CAAC,CAAC,GAAG,OAAO,CAAE,YAAW,WAAW,CAAC,CAAC,CAAC;IAChE,OAAO,EAAE,KAAK,CAAC;IACf,SAAS,EAAE,CAAC,SAAS,mBAAmB,GAAG,gBAAgB,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;gBACpE,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,SAAS,mBAAmB,GAAG,gBAAgB,CAAC,CAAC,CAAC,GAAG,MAAM;IAKjG,IAAI,MAAM,IAAI,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,WAAW,GAAG,WAAW,GAAG,SAAS,CAAC,CASvE;IAED,IAAI,UAAU,IAAI,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,eAAe,CAAC,CAGrD;IAED,IAAI,mBAAmB,IAAI,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,kBAAkB,CAAC,CAKjE;IAED,aAAa,CAAC,CAAC,SAAS,WAAW,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,SAAS,EAAE,eAAe,KAAK,IAAI,EAAE,OAAO,CAAC,EAAE,CAAC;IAO3G,gBAAgB,CAAC,CAAC,SAAS,WAAW,CAAC,CAAC,CAAC,EACvC,QAAQ,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,YAAY,EAAE,kBAAkB,KAAK,IAAI,EAC5D,OAAO,CAAC,EAAE,CAAC;IAUb,wBAAwB,CAAC,CAAC,SAAS,WAAW,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,EAAE,OAAO,CAAC,EAAE,CAAC;CAQhH"}

package/unstable-preview-types/-private/managers/cache-capabilities-manager.d.ts

@@ -0,0 +1,27 @@
+import type { StableDocumentIdentifier, StableRecordIdentifier } from '@warp-drive/core-types/identifier';
+import type { CacheCapabilitiesManager as StoreWrapper } from '../../-types/q/cache-store-wrapper';
+import type { SchemaService } from '../../-types/q/schema-service';
+import type { IdentifierCache } from '../caches/identifier-cache';
+import type Store from '../store-service';
+import type { NotificationType } from './notification-manager';
+/**
+  @module @ember-data/store
+*/
+export declare class CacheCapabilitiesManager implements StoreWrapper {
+    _willNotify: boolean;
+    _pendingNotifies: Map<StableRecordIdentifier, Set<string>>;
+    _store: Store;
+    constructor(_store: Store);
+    get identifierCache(): IdentifierCache;
+    _scheduleNotification(identifier: StableRecordIdentifier, key: string): void;
+    _flushNotifications(): void;
+    notifyChange(identifier: StableRecordIdentifier, namespace: 'added' | 'removed'): void;
+    notifyChange(identifier: StableDocumentIdentifier, namespace: 'added' | 'updated' | 'removed'): void;
+    notifyChange(identifier: StableRecordIdentifier, namespace: NotificationType, key?: string): void;
+    getSchemaDefinitionService(): SchemaService;
+    get schema(): SchemaService;
+    setRecordId(identifier: StableRecordIdentifier, id: string): void;
+    hasRecord(identifier: StableRecordIdentifier): boolean;
+    disconnectRecord(identifier: StableRecordIdentifier): void;
+}
+//# sourceMappingURL=cache-capabilities-manager.d.ts.map

package/unstable-preview-types/-private/managers/cache-capabilities-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-capabilities-manager.d.ts","sourceRoot":"","sources":["../../../src/-private/managers/cache-capabilities-manager.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,wBAAwB,EAAE,sBAAsB,EAAE,MAAM,mCAAmC,CAAC;AAE1G,OAAO,KAAK,EAAE,wBAAwB,IAAI,YAAY,EAAE,MAAM,oCAAoC,CAAC;AACnG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AACnE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAElE,OAAO,KAAK,KAAK,MAAM,kBAAkB,CAAC;AAC1C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/D;;EAEE;AAEF,qBAAa,wBAAyB,YAAW,YAAY;IACnD,WAAW,EAAE,OAAO,CAAC;IACrB,gBAAgB,EAAE,GAAG,CAAC,sBAAsB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;IAC3D,MAAM,EAAE,KAAK,CAAC;gBAEV,MAAM,EAAE,KAAK;IAMzB,IAAI,eAAe,IAAI,eAAe,CAErC;IAED,qBAAqB,CAAC,UAAU,EAAE,sBAAsB,EAAE,GAAG,EAAE,MAAM;IAyBrE,mBAAmB,IAAI,IAAI;IAgB3B,YAAY,CAAC,UAAU,EAAE,sBAAsB,EAAE,SAAS,EAAE,OAAO,GAAG,SAAS,GAAG,IAAI;IACtF,YAAY,CAAC,UAAU,EAAE,wBAAwB,EAAE,SAAS,EAAE,OAAO,GAAG,SAAS,GAAG,SAAS,GAAG,IAAI;IACpG,YAAY,CAAC,UAAU,EAAE,sBAAsB,EAAE,SAAS,EAAE,gBAAgB,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI;IAkBjG,0BAA0B,IAAI,aAAa;IAI3C,IAAI,MAAM,kBAET;IAED,WAAW,CAAC,UAAU,EAAE,sBAAsB,EAAE,EAAE,EAAE,MAAM;IAK1D,SAAS,CAAC,UAAU,EAAE,sBAAsB,GAAG,OAAO;IAItD,gBAAgB,CAAC,UAAU,EAAE,sBAAsB,GAAG,IAAI;CAK3D"}

package/unstable-preview-types/-private/managers/cache-manager.d.ts

@@ -0,0 +1,440 @@
+import type { Cache, ChangedAttributesHash, RelationshipDiff } from '@warp-drive/core-types/cache';
+import type { Change } from '@warp-drive/core-types/cache/change';
+import type { CollectionRelationship, ResourceRelationship } from '@warp-drive/core-types/cache/relationship';
+import type { LocalRelationshipOperation } from '@warp-drive/core-types/graph';
+import type { StableDocumentIdentifier, StableRecordIdentifier } from '@warp-drive/core-types/identifier';
+import type { Value } from '@warp-drive/core-types/json/raw';
+import type { StructuredDataDocument, StructuredDocument } from '@warp-drive/core-types/request';
+import type { ResourceDocument, SingleResourceDataDocument } from '@warp-drive/core-types/spec/document';
+import type { ApiError } from '@warp-drive/core-types/spec/error';
+import type { MergeOperation } from '../../-types/q/cache';
+import type { JsonApiResource } from '../../-types/q/record-data-json-api';
+import type { StoreRequestContext } from '../cache-handler';
+/**
+ * The CacheManager wraps a Cache enforcing that only
+ * the public API surface area is exposed.
+ *
+ * Hence, it is the value of `Store.cache`, wrapping
+ * the cache instance returned by `Store.createCache`.
+ *
+ * It handles translating between cache versions when
+ * necessary, for instance when a Store is configured
+ * to use both a v1 and a v2 cache depending on some
+ * heuristic.
+ *
+ * Starting with the v2 spec, the cache is designed such
+ * that it must be implemented as a singleton.
+ *
+ * @class CacheManager
+ * @public
+ */
+export declare class CacheManager implements Cache {
+    #private;
+    version: "2";
+    constructor(cache: Cache);
+    /**
+     * Cache the response to a request
+     *
+     * Unlike `store.push` which has UPSERT
+     * semantics, `put` has `replace` semantics similar to
+     * the `http` method `PUT`
+     *
+     * the individually cacheable
+     * e resource data it may contain
+     * should upsert, but the document data surrounding it should
+     * fully replace any existing information
+     *
+     * Note that in order to support inserting arbitrary data
+     * to the cache that did not originate from a request `put`
+     * should expect to sometimes encounter a document with only
+     * a `content` member and therefor must not assume the existence
+     * of `request` and `response` on the document.
+     *
+     * @method put
+     * @param {StructuredDocument} doc
+     * @return {ResourceDocument}
+     * @public
+     */
+    put<T>(doc: StructuredDocument<T> | {
+        content: T;
+    }): ResourceDocument;
+    /**
+     * Perform an operation on the cache to update the remote state.
+     *
+     * Note: currently the only valid operation is a MergeOperation
+     * which occurs when a collision of identifiers is detected.
+     *
+     * @method patch
+     * @public
+     * @param op the operation to perform
+     * @return {void}
+     */
+    patch(op: MergeOperation): void;
+    /**
+     * Update resource data with a local mutation. Currently supports operations
+     * on relationships only.
+     *
+     * @method mutate
+     * @public
+     * @param mutation
+     */
+    mutate(mutation: LocalRelationshipOperation): void;
+    /**
+     * Peek resource data from the Cache.
+     *
+     * In development, if the return value
+     * is JSON the return value
+     * will be deep-cloned and deep-frozen
+     * to prevent mutation thereby enforcing cache
+     * Immutability.
+     *
+     * This form of peek is useful for implementations
+     * that want to feed raw-data from cache to the UI
+     * or which want to interact with a blob of data
+     * directly from the presentation cache.
+     *
+     * An implementation might want to do this because
+     * de-referencing records which read from their own
+     * blob is generally safer because the record does
+     * not require retaining connections to the Store
+     * and Cache to present data on a per-field basis.
+     *
+     * This generally takes the place of `getAttr` as
+     * an API and may even take the place of `getRelationship`
+     * depending on implementation specifics, though this
+     * latter usage is less recommended due to the advantages
+     * of the Graph handling necessary entanglements and
+     * notifications for relational data.
+     *
+     * @method peek
+     * @public
+     * @param {StableRecordIdentifier | StableDocumentIdentifier} identifier
+     * @return {ResourceDocument | ResourceBlob | null} the known resource data
+     */
+    peek(identifier: StableRecordIdentifier): unknown;
+    peek(identifier: StableDocumentIdentifier): ResourceDocument | null;
+    /**
+     * Peek the Cache for the existing request data associated with
+     * a cacheable request
+     *
+     * @method peekRequest
+     * @param {StableDocumentIdentifier}
+     * @return {StableDocumentIdentifier | null}
+     * @public
+     */
+    peekRequest(identifier: StableDocumentIdentifier): StructuredDocument<ResourceDocument> | null;
+    /**
+     * Push resource data from a remote source into the cache for this identifier
+     *
+     * @method upsert
+     * @public
+     * @param identifier
+     * @param data
+     * @param hasRecord
+     * @return {void | string[]} if `hasRecord` is true then calculated key changes should be returned
+     */
+    upsert(identifier: StableRecordIdentifier, data: JsonApiResource, hasRecord: boolean): void | string[];
+    /**
+     * Create a fork of the cache from the current state.
+     *
+     * Applications should typically not call this method themselves,
+     * preferring instead to fork at the Store level, which will
+     * utilize this method to fork the cache.
+     *
+     * @method fork
+     * @public
+     * @return Promise<Cache>
+     */
+    fork(): Promise<Cache>;
+    /**
+     * Merge a fork back into a parent Cache.
+     *
+     * Applications should typically not call this method themselves,
+     * preferring instead to merge at the Store level, which will
+     * utilize this method to merge the caches.
+     *
+     * @method merge
+     * @param {Cache} cache
+     * @public
+     * @return Promise<void>
+     */
+    merge(cache: Cache): Promise<void>;
+    /**
+     * Generate the list of changes applied to all
+     * record in the store.
+     *
+     * Each individual resource or document that has
+     * been mutated should be described as an individual
+     * `Change` entry in the returned array.
+     *
+     * A `Change` is described by an object containing up to
+     * three properties: (1) the `identifier` of the entity that
+     * changed; (2) the `op` code of that change being one of
+     * `upsert` or `remove`, and if the op is `upsert` a `patch`
+     * containing the data to merge into the cache for the given
+     * entity.
+     *
+     * This `patch` is opaque to the Store but should be understood
+     * by the Cache and may expect to be utilized by an Adapter
+     * when generating data during a `save` operation.
+     *
+     * It is generally recommended that the `patch` contain only
+     * the updated state, ignoring fields that are unchanged
+     *
+     * ```ts
+     * interface Change {
+     *  identifier: StableRecordIdentifier | StableDocumentIdentifier;
+     *  op: 'upsert' | 'remove';
+     *  patch?: unknown;
+     * }
+     * ```
+     *
+     * @method diff
+     * @public
+     */
+    diff(): Promise<Change[]>;
+    /**
+     * Serialize the entire contents of the Cache into a Stream
+     * which may be fed back into a new instance of the same Cache
+     * via `cache.hydrate`.
+     *
+     * @method dump
+     * @return {Promise<ReadableStream>}
+     * @public
+     */
+    dump(): Promise<ReadableStream<unknown>>;
+    /**
+     * hydrate a Cache from a Stream with content previously serialized
+     * from another instance of the same Cache, resolving when hydration
+     * is complete.
+     *
+     * This method should expect to be called both in the context of restoring
+     * the Cache during application rehydration after SSR **AND** at unknown
+     * times during the lifetime of an already booted application when it is
+     * desired to bulk-load additional information into the cache. This latter
+     * behavior supports optimizing pre/fetching of data for route transitions
+     * via data-only SSR modes.
+     *
+     * @method hydrate
+     * @param {ReadableStream} stream
+     * @return {Promise<void>}
+     * @public
+     */
+    hydrate(stream: ReadableStream<unknown>): Promise<void>;
+    /**
+     * [LIFECYCLE] Signal to the cache that a new record has been instantiated on the client
+     *
+     * It returns properties from options that should be set on the record during the create
+     * process. This return value behavior is deprecated.
+     *
+     * @method clientDidCreate
+     * @public
+     * @param identifier
+     * @param options
+     */
+    clientDidCreate(identifier: StableRecordIdentifier, options?: Record<string, unknown>): Record<string, unknown>;
+    /**
+     * [LIFECYCLE] Signals to the cache that a resource
+     * will be part of a save transaction.
+     *
+     * @method willCommit
+     * @public
+     * @param identifier
+     */
+    willCommit(identifier: StableRecordIdentifier, context: StoreRequestContext): void;
+    /**
+     * [LIFECYCLE] Signals to the cache that a resource
+     * was successfully updated as part of a save transaction.
+     *
+     * @method didCommit
+     * @public
+     * @param identifier
+     * @param data
+     */
+    didCommit(identifier: StableRecordIdentifier, result: StructuredDataDocument<unknown>): SingleResourceDataDocument;
+    /**
+     * [LIFECYCLE] Signals to the cache that a resource
+     * was update via a save transaction failed.
+     *
+     * @method commitWasRejected
+     * @public
+     * @param identifier
+     * @param errors
+     */
+    commitWasRejected(identifier: StableRecordIdentifier, errors?: ApiError[]): void;
+    /**
+     * [LIFECYCLE] Signals to the cache that all data for a resource
+     * should be cleared.
+     *
+     * @method unloadRecord
+     * @public
+     * @param identifier
+     */
+    unloadRecord(identifier: StableRecordIdentifier): void;
+    /**
+     * Retrieve the data for an attribute from the cache
+     *
+     * @method getAttr
+     * @public
+     * @param identifier
+     * @param propertyName
+     * @return {unknown}
+     */
+    getAttr(identifier: StableRecordIdentifier, propertyName: string): Value | undefined;
+    /**
+     * Mutate the data for an attribute in the cache
+     *
+     * @method setAttr
+     * @public
+     * @param identifier
+     * @param propertyName
+     * @param value
+     */
+    setAttr(identifier: StableRecordIdentifier, propertyName: string, value: Value): void;
+    /**
+     * Query the cache for the changed attributes of a resource.
+     *
+     * @method changedAttrs
+     * @public
+     * @param identifier
+     * @return
+     */
+    changedAttrs(identifier: StableRecordIdentifier): ChangedAttributesHash;
+    /**
+     * Query the cache for whether any mutated attributes exist
+     *
+     * @method hasChangedAttrs
+     * @public
+     * @param identifier
+     * @return {boolean}
+     */
+    hasChangedAttrs(identifier: StableRecordIdentifier): boolean;
+    /**
+     * Tell the cache to discard any uncommitted mutations to attributes
+     *
+     * @method rollbackAttrs
+     * @public
+     * @param identifier
+     * @return the names of attributes that were restored
+     */
+    rollbackAttrs(identifier: StableRecordIdentifier): string[];
+    /**
+     * Query the cache for the changes to relationships of a resource.
+     *
+     * Returns a map of relationship names to RelationshipDiff objects.
+     *
+     * ```ts
+     * type RelationshipDiff =
+    | {
+        kind: 'collection';
+        remoteState: StableRecordIdentifier[];
+        additions: Set<StableRecordIdentifier>;
+        removals: Set<StableRecordIdentifier>;
+        localState: StableRecordIdentifier[];
+        reordered: boolean;
+      }
+    | {
+        kind: 'resource';
+        remoteState: StableRecordIdentifier | null;
+        localState: StableRecordIdentifier | null;
+      };
+      ```
+     *
+     * @method changedRelationships
+     * @public
+     * @param {StableRecordIdentifier} identifier
+     * @return {Map<string, RelationshipDiff>}
+     */
+    changedRelationships(identifier: StableRecordIdentifier): Map<string, RelationshipDiff>;
+    /**
+     * Query the cache for whether any mutated attributes exist
+     *
+     * @method hasChangedRelationships
+     * @public
+     * @param {StableRecordIdentifier} identifier
+     * @return {boolean}
+     */
+    hasChangedRelationships(identifier: StableRecordIdentifier): boolean;
+    /**
+     * Tell the cache to discard any uncommitted mutations to relationships.
+     *
+     * This will also discard the change on any appropriate inverses.
+     *
+     * This method is a candidate to become a mutation
+     *
+     * @method rollbackRelationships
+     * @public
+     * @param {StableRecordIdentifier} identifier
+     * @return {string[]} the names of relationships that were restored
+     */
+    rollbackRelationships(identifier: StableRecordIdentifier): string[];
+    /**
+     * Query the cache for the current state of a relationship property
+     *
+     * @method getRelationship
+     * @public
+     * @param identifier
+     * @param propertyName
+     * @return resource relationship object
+     */
+    getRelationship(identifier: StableRecordIdentifier, propertyName: string): ResourceRelationship | CollectionRelationship;
+    /**
+     * Update the cache state for the given resource to be marked as locally deleted,
+     * or remove such a mark.
+     *
+     * @method setIsDeleted
+     * @public
+     * @param identifier
+     * @param isDeleted
+     */
+    setIsDeleted(identifier: StableRecordIdentifier, isDeleted: boolean): void;
+    /**
+     * Query the cache for any validation errors applicable to the given resource.
+     *
+     * @method getErrors
+     * @public
+     * @param identifier
+     * @return
+     */
+    getErrors(identifier: StableRecordIdentifier): ApiError[];
+    /**
+     * Query the cache for whether a given resource has any available data
+     *
+     * @method isEmpty
+     * @public
+     * @param identifier
+     * @return {boolean}
+     */
+    isEmpty(identifier: StableRecordIdentifier): boolean;
+    /**
+     * Query the cache for whether a given resource was created locally and not
+     * yet persisted.
+     *
+     * @method isNew
+     * @public
+     * @param identifier
+     * @return {boolean}
+     */
+    isNew(identifier: StableRecordIdentifier): boolean;
+    /**
+     * Query the cache for whether a given resource is marked as deleted (but not
+     * necessarily persisted yet).
+     *
+     * @method isDeleted
+     * @public
+     * @param identifier
+     * @return {boolean}
+     */
+    isDeleted(identifier: StableRecordIdentifier): boolean;
+    /**
+     * Query the cache for whether a given resource has been deleted and that deletion
+     * has also been persisted.
+     *
+     * @method isDeletionCommitted
+     * @public
+     * @param identifier
+     * @return {boolean}
+     */
+    isDeletionCommitted(identifier: StableRecordIdentifier): boolean;
+}
+//# sourceMappingURL=cache-manager.d.ts.map

package/unstable-preview-types/-private/managers/cache-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-manager.d.ts","sourceRoot":"","sources":["../../../src/-private/managers/cache-manager.ts"],"names":[],"mappings":"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"}