@warp-drive/core 5.6.0-alpha.5 → 5.6.0-beta.0

package/README.md

@@ -1,13 +1,13 @@
 <h1 align="center">
   <img
-    class="project-logo"
-    src="https://github.com/emberjs/data/blob/main/logos/github-header.svg#gh-light-mode-only"
+    class="project-logo light-only"
+    src="./logos/github-header.svg#gh-light-mode-only"
     alt="WarpDrive | Boldly go where no app has gone before"
     title="WarpDrive | Boldly go where no app has gone before"
     />
   <img
-    class="project-logo"
-    src="https://github.com/emberjs/data/blob/main/logos/github-header.svg#gh-dark-mode-only"
+    class="project-logo dark-only"
+    src="./logos/github-header.svg#gh-dark-mode-only"
     alt="WarpDrive | Boldly go where no app has gone before"
     title="WarpDrive | Boldly go where no app has gone before"
     />
@@ -25,8 +25,9 @@
   <a href="https://warp-drive.io">WarpDrive</a> is a lightweight data library for web apps &mdash;
   <br>
   universal, typed, reactive, and ready to scale.
-  <br/><br/>
-<p>
+  <br>
+  <br>
+</p>
 
 WarpDrive provides features that make it easy to build scalable, fast, feature
 rich application &mdash; letting you ship better experiences more quickly without re-architecting your app or API. WarpDrive is:
@@ -53,7 +54,7 @@ rich application &mdash; letting you ship better experiences more quickly withou
 ## Installation
 
 ```sh
-pnpm add @warp-drive/core
+pnpm add -E @warp-drive/core@latest
 ```
 
 <br>

package/cjs-dist/addon-shim.cjs

@@ -0,0 +1 @@
+module.exports = require('@warp-drive/build-config/addon-shim.cjs');

package/cjs-dist/cjs-set-config.cjs

@@ -0,0 +1 @@
+module.exports = require('@warp-drive/build-config/cjs-set-config.cjs');

package/declarations/build-config/babel-macros.d.ts

@@ -0,0 +1 @@
+export { macros } from "@warp-drive/build-config/babel-macros";

package/declarations/build-config/canary-features.d.ts

@@ -0,0 +1 @@
+export * from "@warp-drive/build-config/canary-features";

package/declarations/build-config/debugging.d.ts

@@ -0,0 +1 @@
+export * from "@warp-drive/build-config/debugging";

package/declarations/build-config/deprecations.d.ts

@@ -0,0 +1 @@
+export * from "@warp-drive/build-config/deprecations";

package/declarations/build-config/env.d.ts

@@ -0,0 +1 @@
+export { DEBUG, PRODUCTION, IS_CI, IS_RECORDING, SHOULD_RECORD, TESTING } from "@warp-drive/build-config/env";

package/declarations/build-config/macros.d.ts

@@ -0,0 +1 @@
+export { assert } from "@warp-drive/build-config/macros";

package/declarations/build-config.d.ts

@@ -0,0 +1 @@
+export { setConfig } from "@warp-drive/build-config";

package/declarations/configure.d.ts

@@ -0,0 +1,7 @@
+/**
+* Provides a configuration API for the reactivity system
+* that WarpDrive should use.
+*
+* @module
+*/
+export { setupSignals, type HooksOptions, type SignalHooks } from "./store/-private/new-core-tmp/reactivity/configure.js";

package/declarations/graph/-private/-diff.d.ts

@@ -0,0 +1,32 @@
+import type { StableRecordIdentifier } from "../../types/identifier.js";
+import type { CollectionEdge } from "./edges/collection.js";
+import type { ResourceEdge } from "./edges/resource.js";
+import type { Graph } from "./graph.js";
+type Diff<T> = {
+	add: Set<T>;
+	del: Set<T>;
+	finalState: T[];
+	finalSet: Set<T>;
+	changed: boolean;
+	remoteOrderChanged: boolean;
+};
+export declare function diffCollection(finalState: StableRecordIdentifier[], relationship: CollectionEdge, onAdd: (v: StableRecordIdentifier) => void, onDel: (v: StableRecordIdentifier) => void): Diff<StableRecordIdentifier>;
+export declare function computeLocalState(storage: CollectionEdge): StableRecordIdentifier[];
+/**
+* A function which attempts to add a value to the local state of a collection
+* relationship, and returns true if the value was added, or false if it was
+* already present.
+*
+* It will not generate a notification, will not update the relationships to dirty,
+* and will not update the inverse relationships, making it suitable for use as
+* an internal util to perform the just the addition to a specific side of a
+* relationship.
+*
+* @internal
+*/
+export declare function _add(graph: Graph, record: StableRecordIdentifier, relationship: CollectionEdge, value: StableRecordIdentifier, index: number | null, isRemote: boolean): boolean;
+export declare function _remove(graph: Graph, record: StableRecordIdentifier, relationship: CollectionEdge, value: StableRecordIdentifier, index: number | null, isRemote: boolean): boolean;
+export declare function _removeLocal(relationship: CollectionEdge, value: StableRecordIdentifier): boolean;
+export declare function _removeRemote(relationship: CollectionEdge, value: StableRecordIdentifier): boolean;
+export declare function rollbackRelationship(graph: Graph, identifier: StableRecordIdentifier, field: string, relationship: CollectionEdge | ResourceEdge): void;
+export {};

package/declarations/graph/-private/-edge-definition.d.ts

@@ -0,0 +1,148 @@
+import type { StableRecordIdentifier } from "../../types.js";
+import type { CollectionField, FieldSchema, LegacyBelongsToField, LegacyHasManyField, ResourceField } from "../../types/schema/fields.js";
+import type { Graph } from "./graph.js";
+export type EdgeCache = Record<string, Record<string, EdgeDefinition | null>>;
+export type RelationshipField = LegacyBelongsToField | LegacyHasManyField | ResourceField | CollectionField;
+export type RelationshipFieldKind = RelationshipField["kind"];
+export type CollectionKind = "hasMany" | "collection";
+export type ResourceKind = "belongsTo" | "resource";
+export declare const RELATIONSHIP_KINDS: string[];
+export declare function isLegacyField(field: FieldSchema): field is LegacyBelongsToField | LegacyHasManyField;
+export declare function isRelationshipField(field: FieldSchema): field is RelationshipField;
+export declare function temporaryConvertToLegacy(field: ResourceField | CollectionField): LegacyBelongsToField | LegacyHasManyField;
+/**
+*
+* Given RHS (Right Hand Side)
+*
+* ```ts
+* class User extends Model {
+*   @hasMany('animal', { async: false, inverse: 'owner' }) pets;
+* }
+* ```
+*
+* Given LHS (Left Hand Side)
+*
+* ```ts
+* class Animal extends Model {
+*  @belongsTo('user', { async: false, inverse: 'pets' }) owner;
+* }
+* ```
+*
+* The UpgradedMeta for the RHS would be:
+*
+* ```ts
+* {
+*   kind: 'hasMany',
+*   key: 'pets',
+*   type: 'animal',
+*   isAsync: false,
+*   isImplicit: false,
+*   isCollection: true,
+*   isPolymorphic: false,
+*   inverseKind: 'belongsTo',
+*   inverseKey: 'owner',
+*   inverseType: 'user',
+*   inverseIsAsync: false,
+*   inverseIsImplicit: false,
+*   inverseIsCollection: false,
+*   inverseIsPolymorphic: false,
+* }
+* ```
+*
+* The UpgradeMeta for the LHS would be:
+*
+* ```ts
+* {
+*   kind: 'belongsTo',
+*   key: 'owner',
+*   type: 'user',
+*   isAsync: false,
+*   isImplicit: false,
+*   isCollection: false,
+*   isPolymorphic: false,
+*   inverseKind: 'hasMany',
+*   inverseKey: 'pets',
+*   inverseType: 'animal',
+*   inverseIsAsync: false,
+*   inverseIsImplicit: false,
+*   inverseIsCollection: true,
+*   inverseIsPolymorphic: false,
+* }
+* ```
+*
+*
+* @class UpgradedMeta
+* @internal
+*/
+export interface UpgradedMeta {
+	kind: "implicit" | RelationshipFieldKind;
+	/**
+	* The field name on `this` record
+	*
+	* @internal
+	*/
+	key: string;
+	/**
+	* The `type` of the related record
+	*
+	* @internal
+	*/
+	type: string;
+	isAsync: boolean;
+	isImplicit: boolean;
+	isCollection: boolean;
+	isPolymorphic: boolean;
+	resetOnRemoteUpdate: boolean;
+	isLinksMode: boolean;
+	inverseKind: "implicit" | RelationshipFieldKind;
+	/**
+	* The field name on the opposing record
+	* @internal
+	*/
+	inverseKey: string;
+	/**
+	* The `type` of `this` record
+	* @internal
+	*/
+	inverseType: string;
+	inverseIsAsync: boolean;
+	inverseIsImplicit: boolean;
+	inverseIsCollection: boolean;
+	inverseIsPolymorphic: boolean;
+	inverseIsLinksMode: boolean;
+}
+export interface EdgeDefinition {
+	lhs_key: string;
+	lhs_modelNames: string[];
+	lhs_baseModelName: string;
+	lhs_relationshipName: string;
+	lhs_definition: UpgradedMeta;
+	lhs_isPolymorphic: boolean;
+	rhs_key: string;
+	rhs_modelNames: string[];
+	rhs_baseModelName: string;
+	rhs_relationshipName: string;
+	rhs_definition: UpgradedMeta | null;
+	rhs_isPolymorphic: boolean;
+	hasInverse: boolean;
+	/**
+	* Whether this relationship points back at the same type.
+	*
+	* If the relationship is polymorphic, this will be true if
+	* it points back at the same abstract type.
+	*
+	* @internal
+	*/
+	isSelfReferential: boolean;
+	/**
+	* If this is a reflexive relationship, this is true
+	* if the relationship also points back at the same
+	* field.
+	*
+	* @internal
+	*/
+	isReflexive: boolean;
+}
+export declare function isLHS(info: EdgeDefinition, type: string, key: string): boolean;
+export declare function isRHS(info: EdgeDefinition, type: string, key: string): boolean;
+export declare function upgradeDefinition(graph: Graph, identifier: StableRecordIdentifier, propertyName: string, isImplicit?: boolean): EdgeDefinition | null;

package/declarations/graph/-private/-state.d.ts

@@ -0,0 +1,96 @@
+export interface RelationshipState {
+	/*
+	This flag indicates whether we should consider the content
+	of this relationship "known".
+	
+	If we have no relationship knowledge, and the relationship
+	is `async`, we will attempt to fetch the relationship on
+	access if it is also stale.
+	
+	Snapshot uses this to tell the difference between unknown
+	(`undefined`) or empty (`null`). The reason for this is that
+	we wouldn't want to serialize  unknown relationships as `null`
+	as that might overwrite remote state.
+	
+	All relationships for a newly created (`store.createRecord()`) are
+	considered known (`hasReceivedData === true`).
+	
+	true when
+	=> we receive a push with either new data or explicit empty (`[]` or `null`)
+	=> the relationship is a belongsTo and we have received data from
+	the other side.
+	
+	false when
+	=> we have received no signal about what data belongs in this relationship
+	=> the relationship is a hasMany and we have only received data from
+	the other side.
+	*/
+	hasReceivedData: boolean;
+	/*
+	Flag that indicates whether an empty relationship is explicitly empty
+	(signaled by push giving us an empty array or null relationship)
+	e.g. an API response has told us that this relationship is empty.
+	
+	Thus far, it does not appear that we actually need this flag; however,
+	@runspired has found it invaluable when debugging relationship tests
+	to determine whether (and why if so) we are in an incorrect state.
+	
+	true when
+	=> we receive a push with explicit empty (`[]` or `null`)
+	=> we have received no signal about what data belongs in this relationship
+	=> on initial create (as no signal is known yet)
+	
+	false at all other times
+	*/
+	isEmpty: boolean;
+	/*
+	This flag indicates whether we should
+	re-fetch the relationship the next time
+	it is accessed.
+	
+	The difference between this flag and `shouldForceReload`
+	is in how we treat the presence of partially missing data:
+	- for a forced reload, we will reload the link or EVERY record
+	- for a stale reload, we will reload the link (if present) else only MISSING records
+	
+	Ideally these flags could be merged, but because we don't give the
+	request layer the option of deciding how to resolve the data being queried
+	we are forced to differentiate for now.
+	
+	It is also possible for a relationship to remain stale after a forced reload; however,
+	in this case `state.hasFailedLoadAttempt` ought to be `true`.
+	
+	false when
+	=> cache.isNew(identifier) on initial setup
+	=> a previously triggered request has resolved
+	=> we get relationship data via push
+	
+	true when
+	=> !cache.isNew(identifier) on initial setup
+	=> an inverse has been unloaded
+	=> we get a new link for the relationship
+	
+	TODO @runspired unskip the acceptance tests and fix these flags
+	*/
+	isStale: boolean;
+	hasFailedLoadAttempt: boolean;
+	/*
+	This flag forces fetch. `true` for a single request once `reload()`
+	has been called `false` at all other times.
+	*/
+	shouldForceReload: boolean;
+	/*
+	This flag indicates whether we should
+	**partially** re-fetch the relationship the
+	next time it is accessed.
+	
+	false when
+	=> initial setup
+	=> a previously triggered request has resolved
+	
+	true when
+	=> an inverse has been unloaded
+	*/
+	hasDematerializedInverse: boolean;
+}
+export declare function createState(): RelationshipState;

package/declarations/graph/-private/-utils.d.ts

@@ -0,0 +1,31 @@
+import type { Store } from "../../store/-private.js";
+import type { CacheCapabilitiesManager } from "../../types.js";
+import type { UpdateResourceRelationshipOperation } from "../../types/cache/operations.js";
+import type { UpdateRelationshipOperation } from "../../types/graph.js";
+import type { StableRecordIdentifier } from "../../types/identifier.js";
+import type { ResourceIdentifierObject } from "../../types/spec/json-api-raw.js";
+import type { UpgradedMeta } from "./-edge-definition.js";
+import type { CollectionEdge } from "./edges/collection.js";
+import type { ImplicitEdge } from "./edges/implicit.js";
+import type { ResourceEdge } from "./edges/resource.js";
+import type { Graph, GraphEdge } from "./graph.js";
+export declare function getStore(wrapper: CacheCapabilitiesManager | {
+	_store: Store;
+}): Store;
+export declare function expandingGet<T>(cache: Record<string, Record<string, T>>, key1: string, key2: string): T | undefined;
+export declare function expandingSet<T>(cache: Record<string, Record<string, T>>, key1: string, key2: string, value: T): void;
+export declare function assertValidRelationshipPayload(graph: Graph, op: UpdateRelationshipOperation | UpdateResourceRelationshipOperation): void;
+export declare function isNew(identifier: StableRecordIdentifier): boolean;
+export declare function isBelongsTo(relationship: GraphEdge): relationship is ResourceEdge;
+export declare function isImplicit(relationship: GraphEdge): relationship is ImplicitEdge;
+export declare function isHasMany(relationship: GraphEdge): relationship is CollectionEdge;
+export declare function forAllRelatedIdentifiers(rel: GraphEdge, cb: (identifier: StableRecordIdentifier) => void): void;
+/*
+Removes the given identifier from BOTH remote AND local state.
+
+This method is useful when either a deletion or a rollback on a new record
+needs to entirely purge itself from an inverse relationship.
+*/
+export declare function removeIdentifierCompletelyFromRelationship(graph: Graph, relationship: GraphEdge, value: StableRecordIdentifier, silenceNotifications?: boolean): void;
+export declare function notifyChange(graph: Graph, relationship: CollectionEdge | ResourceEdge): void;
+export declare function assertRelationshipData(store: Store, identifier: StableRecordIdentifier, data: ResourceIdentifierObject, meta: UpgradedMeta): void;

package/declarations/graph/-private/coerce-id.d.ts

@@ -0,0 +1,10 @@
+// Used by the store to normalize IDs entering the store.  Despite the fact
+// that developers may provide IDs as numbers (e.g., `store.findRecord('person', 1)`),
+// it is important that internally we use strings, since IDs may be serialized
+// and lose type information.  For example, Ember's router may put a record's
+// ID into the URL, and if we later try to deserialize that URL and find the
+// corresponding record, we will not know if it is a string or a number.
+type Coercable = string | number | boolean | null | undefined | symbol;
+export declare function coerceId(id: Coercable): string | null;
+export declare function ensureStringId(id: Coercable): string;
+export {};

package/declarations/graph/-private/debug/assert-polymorphic-type.d.ts

@@ -0,0 +1,18 @@
+import type { CacheCapabilitiesManager } from "../../../types.js";
+import type { StableRecordIdentifier } from "../../../types/identifier.js";
+import { type UpgradedMeta } from "../-edge-definition.js";
+/*
+Assert that `addedRecord` has a valid type so it can be added to the
+relationship of the `record`.
+
+The assert basically checks if the `addedRecord` can be added to the
+relationship (specified via `relationshipMeta`) of the `record`.
+
+This utility should only be used internally, as both record parameters must
+be stable record identifiers and the `relationshipMeta` needs to be the meta
+information about the relationship, retrieved via
+`record.relationshipFor(key)`.
+*/
+declare let assertPolymorphicType: (parentIdentifier: StableRecordIdentifier, parentDefinition: UpgradedMeta, addedIdentifier: StableRecordIdentifier, store: CacheCapabilitiesManager) => void;
+declare let assertInheritedSchema: (definition: UpgradedMeta, type: string) => void;
+export { assertPolymorphicType, assertInheritedSchema };

package/declarations/graph/-private/edges/collection.d.ts

@@ -0,0 +1,39 @@
+import type { CollectionRelationship } from "../../../types/cache/relationship.js";
+import type { StableRecordIdentifier } from "../../../types/identifier.js";
+import type { Links, Meta, PaginationLinks } from "../../../types/spec/json-api-raw.js";
+import type { UpgradedMeta } from "../-edge-definition.js";
+import type { RelationshipState } from "../-state.js";
+export interface CollectionEdge {
+	definition: UpgradedMeta;
+	identifier: StableRecordIdentifier;
+	state: RelationshipState;
+	remoteMembers: Set<StableRecordIdentifier>;
+	remoteState: StableRecordIdentifier[];
+	additions: Set<StableRecordIdentifier> | null;
+	removals: Set<StableRecordIdentifier> | null;
+	meta: Meta | null;
+	links: Links | PaginationLinks | null;
+	localState: StableRecordIdentifier[] | null;
+	/**
+	* Whether the localState for this edge is out-of-sync
+	* with the remoteState.
+	*
+	* if state.hasReceivedData=false we are also
+	* not dirty since there is nothing to sync with.
+	*
+	*/
+	isDirty: boolean;
+	transactionRef: number;
+	/**
+	* Whether data for this edge has been accessed at least once
+	* via `graph.getData`
+	*
+	*/
+	accessed: boolean;
+	_diff?: {
+		add: Set<StableRecordIdentifier>;
+		del: Set<StableRecordIdentifier>;
+	};
+}
+export declare function createCollectionEdge(definition: UpgradedMeta, identifier: StableRecordIdentifier): CollectionEdge;
+export declare function legacyGetCollectionRelationshipData(source: CollectionEdge, getRemoteState: boolean): CollectionRelationship;

package/declarations/graph/-private/edges/implicit.d.ts

@@ -0,0 +1,43 @@
+import type { StableRecordIdentifier } from "../../../types/identifier.js";
+import type { UpgradedMeta } from "../-edge-definition.js";
+export type ImplicitMeta = UpgradedMeta & {
+	kind: "implicit";
+	isImplicit: true;
+};
+/**
+Implicit relationships are relationships which have not been declared but the inverse side exists on
+another record somewhere
+
+For example consider the following two models
+
+::: code-group
+
+```js [./models/comment.js]
+import { Model, attr } from '@warp-drive/legacy/model';
+
+export default class Comment extends Model {
+@attr text;
+}
+```
+
+```js [./models/post.js]
+import { Model, attr, hasMany } from '@warp-drive/legacy/model';
+
+export default class Post extends Model {
+@attr title;
+@hasMany('comment', { async: true, inverse: null }) comments;
+}
+```
+
+:::
+
+Then we would have a implicit 'post' relationship for the comment record in order
+to be do things like remove the comment from the post if the comment were to be deleted.
+*/
+export interface ImplicitEdge {
+	definition: ImplicitMeta;
+	identifier: StableRecordIdentifier;
+	localMembers: Set<StableRecordIdentifier>;
+	remoteMembers: Set<StableRecordIdentifier>;
+}
+export declare function createImplicitEdge(definition: ImplicitMeta, identifier: StableRecordIdentifier): ImplicitEdge;

package/declarations/graph/-private/edges/resource.d.ts

@@ -0,0 +1,24 @@
+import type { ResourceRelationship } from "../../../types/cache/relationship.js";
+import type { StableRecordIdentifier } from "../../../types/identifier.js";
+import type { Links, Meta, PaginationLinks } from "../../../types/spec/json-api-raw.js";
+import type { UpgradedMeta } from "../-edge-definition.js";
+import type { RelationshipState } from "../-state.js";
+/**
+* Stores the data for one side of a "single" resource relationship.
+*
+* @class ResourceEdge
+* @internal
+*/
+export interface ResourceEdge {
+	definition: UpgradedMeta;
+	identifier: StableRecordIdentifier;
+	state: RelationshipState;
+	localState: StableRecordIdentifier | null;
+	remoteState: StableRecordIdentifier | null;
+	meta: Meta | null;
+	links: Links | PaginationLinks | null;
+	transactionRef: number;
+	accessed: boolean;
+}
+export declare function createResourceEdge(definition: UpgradedMeta, identifier: StableRecordIdentifier): ResourceEdge;
+export declare function legacyGetResourceRelationshipData(source: ResourceEdge, getRemoteState: boolean): ResourceRelationship;

package/declarations/graph/-private/graph.d.ts

@@ -0,0 +1,90 @@
+import type { CacheCapabilitiesManager, StableRecordIdentifier } from "../../types.js";
+import type { RelationshipDiff } from "../../types/cache.js";
+import type { MergeOperation } from "../../types/cache/operations.js";
+import type { CollectionRelationship, ResourceRelationship } from "../../types/cache/relationship.js";
+import type { DeleteRecordOperation, LocalRelationshipOperation, RemoteRelationshipOperation } from "../../types/graph.js";
+import type { EdgeCache, UpgradedMeta } from "./-edge-definition.js";
+import { type CollectionEdge } from "./edges/collection.js";
+import type { ImplicitEdge } from "./edges/implicit.js";
+import { type ResourceEdge } from "./edges/resource.js";
+export type GraphEdge = ImplicitEdge | CollectionEdge | ResourceEdge;
+export declare const Graphs: Map<CacheCapabilitiesManager, Graph>;
+type PendingOps = {
+	belongsTo?: Map<string, Map<string, RemoteRelationshipOperation[]>>;
+	hasMany?: Map<string, Map<string, RemoteRelationshipOperation[]>>;
+	deletions: DeleteRecordOperation[];
+};
+/*
+* Graph acts as the cache for relationship data. It allows for
+* us to ask about and update relationships for a given Identifier
+* without requiring other objects for that Identifier to be
+* instantiated (such as `RecordData` or a `Record`)
+*
+* This also allows for us to make more substantive changes to relationships
+* with increasingly minor alterations to other portions of the internals
+* over time.
+*
+* The graph is made up of nodes and edges. Each unique identifier gets
+* its own node, which is a dictionary with a list of that node's edges
+* (or connections) to other nodes. In `Model` terms, a node represents a
+* record instance, with each key (an edge) in the dictionary correlating
+* to either a `hasMany` or `belongsTo` field on that record instance.
+*
+* The value for each key, or `edge` is the identifier(s) the node relates
+* to in the graph from that key.
+*/
+export declare class Graph {
+	_definitionCache: EdgeCache;
+	_metaCache: Record<string, Record<string, UpgradedMeta>>;
+	_potentialPolymorphicTypes: Record<string, Record<string, boolean>>;
+	identifiers: Map<StableRecordIdentifier, Record<string, GraphEdge>>;
+	store: CacheCapabilitiesManager;
+	isDestroyed: boolean;
+	_willSyncRemote: boolean;
+	_willSyncLocal: boolean;
+	silenceNotifications: boolean;
+	_pushedUpdates: PendingOps;
+	_updatedRelationships: Set<CollectionEdge>;
+	_transaction: number | null;
+	_removing: StableRecordIdentifier | null;
+	constructor(store: CacheCapabilitiesManager);
+	has(identifier: StableRecordIdentifier, propertyName: string): boolean;
+	getDefinition(identifier: StableRecordIdentifier, propertyName: string): UpgradedMeta;
+	get(identifier: StableRecordIdentifier, propertyName: string): GraphEdge;
+	getData(identifier: StableRecordIdentifier, propertyName: string): ResourceRelationship | CollectionRelationship;
+	getRemoteData(identifier: StableRecordIdentifier, propertyName: string): ResourceRelationship | CollectionRelationship;
+	/*
+	* Allows for the graph to dynamically discover polymorphic connections
+	* without needing to walk prototype chains.
+	*
+	* Used by edges when an added `type` does not match the expected `type`
+	* for that edge.
+	*
+	* Currently we assert before calling this. For a public API we will want
+	* to call out to the schema manager to ask if we should consider these
+	* types as equivalent for a given relationship.
+	*/
+	registerPolymorphicType(type1: string, type2: string): void;
+	isReleasable(identifier: StableRecordIdentifier): boolean;
+	unload(identifier: StableRecordIdentifier, silenceNotifications?: boolean): void;
+	_isDirty(identifier: StableRecordIdentifier, field: string): boolean;
+	getChanged(identifier: StableRecordIdentifier): Map<string, RelationshipDiff>;
+	hasChanged(identifier: StableRecordIdentifier): boolean;
+	rollback(identifier: StableRecordIdentifier): string[];
+	remove(identifier: StableRecordIdentifier): void;
+	/*
+	* Remote state changes
+	*/
+	push(op: RemoteRelationshipOperation): void;
+	/*
+	* Local state changes
+	*/
+	update(op: RemoteRelationshipOperation | MergeOperation, isRemote: true): void;
+	update(op: LocalRelationshipOperation, isRemote?: false): void;
+	_scheduleLocalSync(relationship: CollectionEdge): void;
+	_flushRemoteQueue(): void;
+	_addToTransaction(relationship: CollectionEdge | ResourceEdge): void;
+	_flushLocalQueue(): void;
+	destroy(): void;
+}
+export {};

package/declarations/graph/-private/normalize-link.d.ts

@@ -0,0 +1,8 @@
+import type { Link, LinkObject } from "../../types/spec/json-api-raw.js";
+/*
+This method normalizes a link to an "links object". If the passed link is
+already an object it's returned without any modifications.
+
+See http://jsonapi.org/format/#document-links for more information.
+*/
+export default function _normalizeLink(link: Link): LinkObject | null;

package/declarations/graph/-private/operations/add-to-related-records.d.ts

@@ -0,0 +1,4 @@
+import type { AddToResourceRelationshipMutation } from "../../../types/cache/mutations.js";
+import type { AddToResourceRelationshipOperation } from "../../../types/cache/operations.js";
+import type { Graph } from "../graph.js";
+export default function addToRelatedRecords(graph: Graph, op: AddToResourceRelationshipOperation | AddToResourceRelationshipMutation, isRemote: boolean): void;

package/declarations/graph/-private/operations/merge-identifier.d.ts

@@ -0,0 +1,3 @@
+import type { MergeOperation } from "../../../types/cache/operations.js";
+import type { Graph, GraphEdge } from "../graph.js";
+export declare function mergeIdentifier(graph: Graph, op: MergeOperation, relationships: Record<string, GraphEdge>): void;

package/declarations/graph/-private/operations/remove-from-related-records.d.ts

@@ -0,0 +1,4 @@
+import type { RemoveFromResourceRelationshipMutation } from "../../../types/cache/mutations.js";
+import type { RemoveFromResourceRelationshipOperation } from "../../../types/cache/operations.js";
+import type { Graph } from "../graph.js";
+export default function removeFromRelatedRecords(graph: Graph, op: RemoveFromResourceRelationshipOperation | RemoveFromResourceRelationshipMutation, isRemote: boolean): void;

package/declarations/graph/-private/operations/replace-related-record.d.ts

@@ -0,0 +1,3 @@
+import type { ReplaceRelatedRecordOperation } from "../../../types/graph.js";
+import type { Graph } from "../graph.js";
+export default function replaceRelatedRecord(graph: Graph, op: ReplaceRelatedRecordOperation, isRemote?: boolean): void;