@warp-drive/core 5.8.0-alpha.3 → 5.8.0-alpha.32

package/dist/unpkg/prod/build-config/macros.js

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

package/dist/unpkg/prod/build-config.js

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

package/dist/unpkg/prod/configure-C3x8YXzL.js

@@ -0,0 +1,181 @@
+import { getOrSetGlobal, peekTransient, setTransient } from './types/-private.js';
+import { macroCondition, getGlobalConfig } from '@embroider/macros';
+const ARRAY_SIGNAL = getOrSetGlobal('#[]', Symbol('#[]'));
+const OBJECT_SIGNAL = getOrSetGlobal('#{}', Symbol('#{}'));
+
+/**
+ * Requirements:
+ *
+ * Signal:
+ *
+ * - signal: a way of creating a reference that we can dirty when we desire to notify
+ *         - @signal: a way of creating an accessor on an object that subscribes to a signal on access
+ *                    and notifies the signal on set, or of upgrading a descriptor to be such an accessor
+ *         - defineSignal: a way of creating a signal on an object
+ *         - notifySignal: a way of notifying the underlying signal that it has been dirtied
+ *         - peekSignal: a way of inspecting the signal without notifying it
+ *
+ *  - gate: a memoized getter function that re-runs when on access if its signal is dirty
+ *          conceptually, a gate is a tightly coupled signal and memo
+ *         - @gate: a way of creating a gate on an object or upgrading a descriptor with a getter
+ *                  to be a gate
+ *         - defineGate: a way of creating a gate on an object
+ *         - notifySignal: a way of notifying the signal for a gate that it has been dirtied
+ *
+ * - memo:
+ *        - @memo: a way of creating a memoized getter on an object or upgrading a descriptor with a getter
+ *                 to be a memo
+ *        - defineMemo: a way of creating a memo on an object
+ *
+ * - signalStore: storage bucket for signals associated to an object
+ *        - withSignalStore: a way of pre-creating a signal store on an object
+ *
+ *
+ * @internal
+ */
+
+/**
+ * An Opaque type that represents a framework specific or TC39 signal.
+ *
+ * It may be an array of signals or a single signal.
+ *
+ * @private
+ */
+
+/**
+ * The hooks which MUST be configured in order to use reactive arrays,
+ * resources and documents with framework specfic signals or TC39 signals.
+ *
+ * Support for multiple frameworks simultaneously can be done via
+ * this abstraction by returning multiple signals from the `createSignal`
+ * method, and consuming the correct one via the correct framework via
+ * the `consumeSignal` and `notifySignal` methods.
+ *
+ * Unlike many signals implementations, WarpDrive does not wrap values as
+ * signals directly, but instead uses signals to alert the reactive layer
+ * to changes in the underlying cache. E.g. a signal is associated to a value,
+ * but does not serve as the cache for that value directly. We refer to this as
+ * a "gate", the pattern has also been called "side-signals".
+ *
+ * A no-op implementation is allowed, though it may lead to performance issues
+ * in locations that use createMemo as no memoization would be done. This is
+ * typically desirable only when integrating with a framework that does its own
+ * memoization and does not integrate with any signals-like primitive. For these
+ * scenarios you may also be interested in integrating with the {@link NotificationManager}
+ * more directly.
+ *
+ * @public
+ */
+
+/**
+ * Contains information a {@link SignalHooks} implementation may want
+ * to use, such as the specialized key used for the signal
+ * representing an array's contents / length.
+ *
+ * ```ts
+ * interface HooksOptions {
+ *   wellknown: {
+ *     Array: symbol | string;
+ *   }
+ * }
+ * ```
+ *
+ * @public
+ */
+
+/**
+ * Configures the signals implementation to use. Supports multiple
+ * implementations simultaneously.
+ *
+ * See {@link HooksOptions} for the options passed to the provided function
+ * when called.
+ *
+ * See {@link SignalHooks} for the implementation the callback function should
+ * return.
+ *
+ * @public
+ * @param buildConfig - a function that takes options and returns a configuration object
+ */
+function setupSignals(buildConfig) {
+  // We want to assert this but can't because too many package manager
+  // and bundler bugs exist that cause this to be called multiple times
+  // for what should be a single call.
+  // assert(`Cannot override configured signal hooks`, peekTransient('signalHooks') === null);
+  const hooks = buildConfig({
+    wellknown: {
+      Array: ARRAY_SIGNAL
+    }
+  });
+  setTransient('signalHooks', hooks);
+}
+
+/**
+ * Internal method for consuming the configured `createSignal` hook
+ *
+ * @private
+ */
+function createSignal(obj, key) {
+  const signalHooks = peekTransient('signalHooks');
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Signal hooks not configured`);
+    }
+  })(signalHooks) : {};
+  return signalHooks.createSignal(obj, key);
+}
+
+/**
+ * Internal method for consuming the configured `consumeSignal` hook
+ *
+ * @private
+ */
+function consumeSignal(signal) {
+  const signalHooks = peekTransient('signalHooks');
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Signal hooks not configured`);
+    }
+  })(signalHooks) : {};
+  return signalHooks.consumeSignal(signal);
+}
+
+/**
+ * Internal method for consuming the configured `notifySignal` hook
+ *
+ * @private
+ */
+function notifySignal(signal) {
+  const signalHooks = peekTransient('signalHooks');
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Signal hooks not configured`);
+    }
+  })(signalHooks) : {};
+  return signalHooks.notifySignal(signal);
+}
+function createMemo(object, key, fn) {
+  const signalHooks = peekTransient('signalHooks');
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Signal hooks not configured`);
+    }
+  })(signalHooks) : {};
+  return signalHooks.createMemo(object, key, fn);
+}
+function willSyncFlushWatchers() {
+  const signalHooks = peekTransient('signalHooks');
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Signal hooks not configured`);
+    }
+  })(signalHooks) : {};
+  return signalHooks.willSyncFlushWatchers();
+}
+function waitFor(promise) {
+  const signalHooks = peekTransient('signalHooks');
+  if (signalHooks?.waitFor) {
+    return signalHooks.waitFor(promise);
+  }
+  return promise;
+}
+export { ARRAY_SIGNAL as A, OBJECT_SIGNAL as O, consumeSignal as a, createMemo as b, createSignal as c, willSyncFlushWatchers as d, notifySignal as n, setupSignals as s, waitFor as w };

package/dist/unpkg/prod/configure.js

@@ -0,0 +1 @@
+export { s as setupSignals } from "./configure-C3x8YXzL.js";

package/dist/unpkg/prod/declarations/build-config/babel-macros.d.ts

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

package/dist/unpkg/prod/declarations/build-config/canary-features.d.ts

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

package/dist/unpkg/prod/declarations/build-config/debugging.d.ts

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

package/dist/unpkg/prod/declarations/build-config/deprecations.d.ts

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

package/dist/unpkg/prod/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/dist/unpkg/prod/declarations/build-config/macros.d.ts

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

package/dist/unpkg/prod/declarations/build-config.d.ts

@@ -0,0 +1,18 @@
+/**
+* This module provides a build-plugin that enables configuration of deprecations,
+* optional features, development/testing support and debug logging.
+*
+* Available settings include:
+*
+* - {@link LOGGING | debugging}
+* - {@link DEPRECATIONS | deprecations}
+* - {@link FEATURES | features}
+* - {@link WarpDriveConfig.polyfillUUID | polyfillUUID}
+* - {@link WarpDriveConfig.includeDataAdapterInProduction | includeDataAdapterInProduction}
+* - {@link WarpDriveConfig.compatWith | compatWith}
+*
+* @module
+*/
+import type { WarpDriveConfig } from "@warp-drive/build-config";
+export { setConfig, babelPlugin } from "@warp-drive/build-config";
+export type { WarpDriveConfig };

package/dist/unpkg/prod/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/dist/unpkg/prod/declarations/graph/-private/-diff.d.ts

@@ -0,0 +1,19 @@
+import type { ResourceKey } 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: ResourceKey[], relationship: CollectionEdge, onAdd: (v: ResourceKey) => void, onDel: (v: ResourceKey) => void): Diff<ResourceKey>;
+export declare function computeLocalState(storage: CollectionEdge): ResourceKey[];
+export declare function _remove(graph: Graph, record: ResourceKey, relationship: CollectionEdge, value: ResourceKey, index: number | null, isRemote: boolean): boolean;
+export declare function _removeLocal(relationship: CollectionEdge, value: ResourceKey): boolean;
+export declare function _removeRemote(relationship: CollectionEdge, value: ResourceKey): boolean;
+export declare function rollbackRelationship(graph: Graph, key: ResourceKey, field: string, relationship: CollectionEdge | ResourceEdge): void;
+export {};

package/dist/unpkg/prod/declarations/graph/-private/-edge-definition.d.ts

@@ -0,0 +1,149 @@
+import type { ResourceKey } 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,
+* }
+* ```
+*
+* @private
+*/
+export interface UpgradedMeta {
+	kind: "implicit" | RelationshipFieldKind;
+	/**
+	* The field sourceKey on `this` record,
+	* name if sourceKey is not set.
+	*/
+	key: string;
+	/**
+	* The field name on `this` record
+	*/
+	name: string;
+	/**
+	* The `type` of the related record
+	*
+	*/
+	type: string;
+	isAsync: boolean;
+	isImplicit: boolean;
+	isCollection: boolean;
+	isPolymorphic: boolean;
+	resetOnRemoteUpdate: boolean;
+	isLinksMode: boolean;
+	inverseKind: "implicit" | RelationshipFieldKind;
+	/**
+	* The field sourceKey on the opposing record,
+	* name if sourceKey is not set.
+	*/
+	inverseKey: string;
+	/**
+	* The field name on the opposing record,
+	*/
+	inverseName: string;
+	/**
+	* The `type` of `this` record
+	*/
+	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.
+	*
+	*/
+	isSelfReferential: boolean;
+	/**
+	* If this is a reflexive relationship, this is true
+	* if the relationship also points back at the same
+	* field.
+	*
+	*/
+	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, key: ResourceKey, propertyName: string, isImplicit?: boolean): EdgeDefinition | null;

package/dist/unpkg/prod/declarations/graph/-private/-state.d.ts

@@ -0,0 +1,9 @@
+export interface RelationshipState {
+	hasReceivedData: boolean;
+	isEmpty: boolean;
+	isStale: boolean;
+	hasFailedLoadAttempt: boolean;
+	shouldForceReload: boolean;
+	hasDematerializedInverse: boolean;
+}
+export declare function createState(): RelationshipState;

package/dist/unpkg/prod/declarations/graph/-private/-utils.d.ts

@@ -0,0 +1,25 @@
+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 { ResourceKey } 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 checkIfNew(store: Store, resourceKey: ResourceKey): 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: (resourceKey: ResourceKey) => void): void;
+export declare function removeIdentifierCompletelyFromRelationship(graph: Graph, relationship: GraphEdge, value: ResourceKey, silenceNotifications?: boolean): void;
+export declare function notifyChange(graph: Graph, relationship: CollectionEdge | ResourceEdge): void;
+export declare function assertRelationshipData(store: Store, resourceKey: ResourceKey, data: ResourceIdentifierObject, meta: UpgradedMeta): void;

package/dist/unpkg/prod/declarations/graph/-private/coerce-id.d.ts

@@ -0,0 +1,4 @@
+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/dist/unpkg/prod/declarations/graph/-private/debug/assert-polymorphic-type.d.ts

@@ -0,0 +1,6 @@
+import type { CacheCapabilitiesManager } from "../../../types.js";
+import type { ResourceKey } from "../../../types/identifier.js";
+import { type UpgradedMeta } from "../-edge-definition.js";
+declare let assertPolymorphicType: (parentIdentifier: ResourceKey, parentDefinition: UpgradedMeta, addedIdentifier: ResourceKey, store: CacheCapabilitiesManager) => void;
+declare let assertInheritedSchema: (definition: UpgradedMeta, type: string) => void;
+export { assertPolymorphicType, assertInheritedSchema };

package/dist/unpkg/prod/declarations/graph/-private/edges/collection.d.ts

@@ -0,0 +1,39 @@
+import type { CollectionRelationship } from "../../../types/cache/relationship.js";
+import type { ResourceKey } 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: ResourceKey;
+	state: RelationshipState;
+	remoteMembers: Set<ResourceKey>;
+	remoteState: ResourceKey[];
+	additions: Set<ResourceKey> | null;
+	removals: Set<ResourceKey> | null;
+	meta: Meta | null;
+	links: Links | PaginationLinks | null;
+	localState: ResourceKey[] | 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<ResourceKey>;
+		del: Set<ResourceKey>;
+	};
+}
+export declare function createCollectionEdge(definition: UpgradedMeta, identifier: ResourceKey): CollectionEdge;
+export declare function legacyGetCollectionRelationshipData(source: CollectionEdge, getRemoteState: boolean): CollectionRelationship;

package/dist/unpkg/prod/declarations/graph/-private/edges/implicit.d.ts

@@ -0,0 +1,43 @@
+import type { ResourceKey } 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: ResourceKey;
+	localMembers: Set<ResourceKey>;
+	remoteMembers: Set<ResourceKey>;
+}
+export declare function createImplicitEdge(definition: ImplicitMeta, identifier: ResourceKey): ImplicitEdge;

package/dist/unpkg/prod/declarations/graph/-private/edges/resource.d.ts

@@ -0,0 +1,23 @@
+import type { ResourceRelationship } from "../../../types/cache/relationship.js";
+import type { ResourceKey } 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.
+*
+* @private
+*/
+export interface ResourceEdge {
+	definition: UpgradedMeta;
+	identifier: ResourceKey;
+	state: RelationshipState;
+	localState: ResourceKey | null;
+	remoteState: ResourceKey | null;
+	meta: Meta | null;
+	links: Links | PaginationLinks | null;
+	transactionRef: number;
+	accessed: boolean;
+}
+export declare function createResourceEdge(definition: UpgradedMeta, identifier: ResourceKey): ResourceEdge;
+export declare function legacyGetResourceRelationshipData(source: ResourceEdge, getRemoteState: boolean): ResourceRelationship;

package/dist/unpkg/prod/declarations/graph/-private/graph.d.ts

@@ -0,0 +1,56 @@
+import type { Store } from "../../store/-private.js";
+import type { CacheCapabilitiesManager, ResourceKey } 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[];
+};
+export declare class Graph {
+	_definitionCache: EdgeCache;
+	_metaCache: Record<string, Record<string, UpgradedMeta>>;
+	_potentialPolymorphicTypes: Record<string, Record<string, boolean>>;
+	identifiers: Map<ResourceKey, Record<string, GraphEdge>>;
+	store: CacheCapabilitiesManager;
+	_realStore: Store;
+	isDestroyed: boolean;
+	_willSyncRemote: boolean;
+	_willSyncLocal: boolean;
+	silenceNotifications: boolean;
+	_pushedUpdates: PendingOps;
+	_updatedRelationships: Set<CollectionEdge>;
+	_transaction: number | null;
+	_removing: ResourceKey | null;
+	constructor(store: CacheCapabilitiesManager);
+	has(resourceKey: ResourceKey, propertyName: string): boolean;
+	getDefinition(resourceKey: ResourceKey, propertyName: string): UpgradedMeta;
+	get(resourceKey: ResourceKey, propertyName: string): GraphEdge;
+	getData(resourceKey: ResourceKey, propertyName: string): ResourceRelationship | CollectionRelationship;
+	getRemoteData(resourceKey: ResourceKey, propertyName: string): ResourceRelationship | CollectionRelationship;
+	registerPolymorphicType(type1: string, type2: string): void;
+	isReleasable(resourceKey: ResourceKey): boolean;
+	unload(resourceKey: ResourceKey, silenceNotifications?: boolean): void;
+	_isDirty(resourceKey: ResourceKey, field: string): boolean;
+	getChanged(resourceKey: ResourceKey): Map<string, RelationshipDiff>;
+	hasChanged(resourceKey: ResourceKey): boolean;
+	rollback(resourceKey: ResourceKey): string[];
+	remove(resourceKey: ResourceKey): void;
+	push(op: RemoteRelationshipOperation): void;
+	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/dist/unpkg/prod/declarations/graph/-private/normalize-link.d.ts

@@ -0,0 +1,2 @@
+import type { Link, LinkObject } from "../../types/spec/json-api-raw.js";
+export default function _normalizeLink(link: Link): LinkObject | null;

package/dist/unpkg/prod/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/dist/unpkg/prod/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/dist/unpkg/prod/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/dist/unpkg/prod/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;

package/dist/unpkg/prod/declarations/graph/-private/operations/replace-related-records.d.ts

@@ -0,0 +1,7 @@
+import type { ResourceKey } from "../../../types.js";
+import type { ReplaceRelatedRecordsOperation } from "../../../types/graph.js";
+import type { Graph } from "../graph.js";
+export default function replaceRelatedRecords(graph: Graph, op: ReplaceRelatedRecordsOperation, isRemote: boolean): void;
+export declare function addToInverse(graph: Graph, resourceKey: ResourceKey, key: string, value: ResourceKey, isRemote: boolean): void;
+export declare function notifyInverseOfPotentialMaterialization(graph: Graph, resourceKey: ResourceKey, key: string, value: ResourceKey, isRemote: boolean): void;
+export declare function removeFromInverse(graph: Graph, resourceKey: ResourceKey, key: string, value: ResourceKey, isRemote: boolean): void;