@warp-drive/core 5.9.0-beta.0 → 5.9.0-beta.2

package/dist/symbols-DjRDCeX0.d.ts

@@ -0,0 +1,88 @@
+//#region src/types/symbols.d.ts
+/**
+ * Symbol used internally to stash a reference to the owning
+ * {@link Store} on a record instance.
+ *
+ * @type {Symbol}
+ */
+declare const RecordStore: "___(unique) Symbol(Store)";
+/**
+ * Symbol for the name of a resource, transformation
+ * or derivation.
+ *
+ * ### With Resources
+ *
+ * This is an optional feature that can be used by
+ * record implementations to provide a typescript
+ * hint for the type of the resource.
+ *
+ * When used, WarpDrive APIs can
+ * take advantage of this to provide better type
+ * safety and intellisense.
+ *
+ * ### With Derivations
+ *
+ * Required for derivations registered with
+ * `store.registerDerivation(derivation)`.
+ *
+ * ```ts
+ * function concat(record: object, options: ObjectValue | null, prop: string): string {}
+ * concat[Name] = 'concat';
+ * ```
+ *
+ * ### With Transforms
+ *
+ * Required for new-style transformations registered
+ * with `store.registerTransform(transform)`.
+ *
+ * For legacy transforms, if not used,
+ * `attr<Transform>('name')` will allow any string name.
+ * `attr('name')` will always allow any string name.
+ *
+ * If used, `attr<Transform>('name')` will enforce
+ * that the name is the same as the transform name.
+ *
+ * @type {Symbol}
+ */
+declare const Type: "___(unique) Symbol($type)";
+/**
+ * Symbol for the type of a resource.
+ *
+ * This is an optional feature that can be used by
+ * record implementations to provide a typescript
+ * hint for the type of the resource.
+ *
+ * When used, WarpDrive APIs can
+ * take advantage of this to provide better type
+ * safety and intellisense.
+ *
+ * @type {Symbol}
+ */
+declare const ResourceType: "___(unique) Symbol($type)";
+/**
+ * Symbol for the name of a transform.
+ *
+ * This is an optional feature that can be used by
+ * transform implementations to provide a typescript
+ * hint for the name of the transform.
+ *
+ * If not used, `attr<Transform>('name')` will
+ * allow any string name. `attr('name')` will always
+ * allow any string name.
+ *
+ * If used, `attr<Transform>('name')` will enforce
+ * that the name is the same as the transform name.
+ *
+ * @type {Symbol}
+ */
+declare const TransformName: "___(unique) Symbol($type)";
+/**
+ * Symbol for use by builders to indicate the return type
+ * generic to use for store.request()
+ *
+ * @type {Symbol}
+ */
+declare const RequestSignature: "___(unique) Symbol(RequestSignature)";
+//#endregion
+export { Type as a, TransformName as i, RequestSignature as n, ResourceType as r, RecordStore as t };
+//# sourceMappingURL=symbols-DjRDCeX0.d.ts.map

package/dist/symbols-DjRDCeX0.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbols-DjRDCeX0.d.ts","names":[],"sources":["../src/types/symbols.ts"],"mappings":";;;;;;;cAUa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwCA;;;;;;;;;;;;;;cAeA;;;;;;;;;;;;;;;;;cAkBA;;;;;;;cAQA"}

package/dist/types/-private.d.ts

@@ -0,0 +1,76 @@
+//#region src/types/-private.d.ts
+type UniversalTransientKey = "REQ_ID";
+type UniversalKey = `(transient) ${UniversalTransientKey}` | "RequestMap" | "PromiseCache" | "RequestCache" | "SkipCache" | "EnableHydration" | "WarpDriveRuntimeConfig";
+type TransientKey = "transactionRef" | "configuredGenerationMethod" | "configuredUpdateMethod" | "configuredForgetMethod" | "configuredResetMethod" | "configuredKeyInfoMethod" | "signalHooks";
+type GlobalKey = `(transient) ${TransientKey}` | "AdapterError" | "InvalidError" | "TimeoutError" | "AbortError" | "UnauthorizedError" | "ForbiddenError" | "NotFoundError" | "ConflictError" | "ServerError" | "#{}" | "#[]" | "Signals" | "AvailableShims" | "FAKE_ARR" | "#source" | "#update" | "#notify" | "IS_COLLECTION" | "Touching" | "RequestPromise" | "SaveOp" | "LEGACY_SUPPORT" | "LegacySupport" | "Graphs" | "IS_FROZEN" | "IS_CACHE_HANDLER" | "CONFIG" | "DEBUG_MAP" | "IDENTIFIERS" | "DOCUMENTS" | "RecordCache" | "StoreMap" | "Store" | "$type" | "TransformName" | "RequestSignature" | "IS_FUTURE" | "DOC" | "UnscopedChannel" | "ManagedArrayMap" | "ManagedObjectMap" | "Support" | "SOURCE" | "Destroy" | "Checkout" | "Commit" | "Context";
+type UniqueSymbol<T extends string> = `___(unique) Symbol(${T})`;
+type UniqueSymbolOr<T, K extends string> = T extends symbol ? UniqueSymbol<K> : T;
+/**
+ * Coordinates creation of a singleton `value` (e.g. a symbol, WeakMap, or
+ * error class) for `key` so that duplicate copies of this package loaded
+ * into the same process observe the same instance instead of each creating
+ * their own.
+ *
+ * In `TESTING` builds this stores/reads `value` from a cache namespaced to
+ * this package's name on `globalThis` (see the file-level comments above for
+ * why this is necessary). Outside of `TESTING`, only one copy of the package
+ * is expected to exist, so this is a no-op that always returns `value`
+ * unchanged.
+ *
+ * The return type lies about symbols being unique to work around the d.ts
+ * rollup issue described in `reactive/-private/symbols.ts`.
+ *
+ * @private
+ */
+declare function getOrSetGlobal<T, K extends GlobalKey>(key: K, value: T): UniqueSymbolOr<T, K>;
+/**
+ * Reads back the current value stored for `key` by {@link setTransient}, or
+ * `null` if nothing has been stored yet.
+ *
+ * Unlike {@link getOrSetGlobal}, this always reads through the same
+ * package-namespaced cache regardless of the `TESTING` flag, since this is
+ * used for genuinely mutable state (not just singleton values) that must
+ * stay in sync across any duplicate copies of this package.
+ *
+ * @private
+ */
+declare function peekTransient<T>(key: TransientKey): T | null;
+/**
+ * Stores `value` for `key`, overwriting whatever was previously stored, so
+ * that it can later be read back via {@link peekTransient}.
+ *
+ * See {@link peekTransient} for details on when/why this cache is shared.
+ *
+ * @private
+ */
+declare function setTransient<T>(key: TransientKey, value: T): T;
+/**
+ * Like {@link getOrSetGlobal}, but reads/writes a cache that is shared across
+ * *all* copies of WarpDrive on `globalThis`, regardless of package name.
+ *
+ * This is used for keys (e.g. request/promise caches) that must be
+ * coordinated even across "mirror" packages published under different
+ * names, rather than only across duplicate copies of the same package name.
+ *
+ * @private
+ */
+declare function getOrSetUniversal<T, K extends UniversalKey>(key: K, value: T): UniqueSymbolOr<T, K>;
+/**
+ * Like {@link peekTransient}, but reads from the package-name-independent
+ * cache used by {@link getOrSetUniversal}. Always reads through this shared
+ * cache regardless of the `TESTING` flag.
+ *
+ * @private
+ */
+declare function peekUniversalTransient<T>(key: UniversalTransientKey): T | null;
+/**
+ * Like {@link setTransient}, but writes to the package-name-independent
+ * cache used by {@link getOrSetUniversal}, so it can later be read via
+ * {@link peekUniversalTransient}.
+ *
+ * @private
+ */
+declare function setUniversalTransient<T>(key: UniversalTransientKey, value: T): T;
+//#endregion
+export { getOrSetGlobal, getOrSetUniversal, peekTransient, peekUniversalTransient, setTransient, setUniversalTransient };
+//# sourceMappingURL=-private.d.ts.map

package/dist/types/-private.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"-private.d.ts","names":[],"sources":["../../src/types/-private.ts"],"mappings":";KAMK;KAIA,8BACc;KAWd;KAWA,2BACc;KA8Gd,aAAa,0CAA0C;KACvD,eAAe,GAAG,oBAAoB,mBAAmB,aAAa,KAAK;;;;;;;;;;;;;;;;;;iBAmBhE,eAAe,GAAG,UAAU,WAAW,KAAK,GAAG,OAAO,IAAI,eAAe,GAAG;;;;;;;;;;;;iBAwB5E,cAAc,GAAG,KAAK,eAAe;;;;;;;;;iBAarC,aAAa,GAAG,KAAK,cAAc,OAAO,IAAI;;;;;;;;;;;iBAe9C,kBAAkB,GAAG,UAAU,cAAc,KAAK,GAAG,OAAO,IAAI,eAAe,GAAG;;;;;;;;iBAoBlF,uBAAuB,GAAG,KAAK,wBAAwB;;;;;;;;iBAYvD,sBAAsB,GAAG,KAAK,uBAAuB,OAAO,IAAI"}

package/dist/types/-private.js

@@ -1,79 +1,3 @@
-import { macroCondition, getGlobalConfig } from '@embroider/macros';
-const name = "@warp-drive/core";
-const version = "5.9.0-beta.0";
+import { a as setTransient, i as peekUniversalTransient, n as getOrSetUniversal, o as setUniversalTransient, r as peekTransient, t as getOrSetGlobal } from "../-private-CyhhcK1a.js";
 
-// in testing mode, we utilize globals to ensure only one copy exists of
-// these maps, due to bugs in ember-auto-import
-
-const GlobalRef = globalThis;
-const UniversalCache = GlobalRef.__warpDrive_universalCache = GlobalRef.__warpDrive_universalCache ?? {};
-
-// in order to support mirror packages, we ensure that each
-// unique package name has its own global cache
-GlobalRef[name] = GlobalRef[name] ?? {
-  __version: version
-};
-const GlobalSink = GlobalRef[name];
-if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
-  if (GlobalSink.__version !== version) {
-    throw new Error('Multiple versions of WarpDrive detected, the application will malfunction.');
-  }
-}
-const ModuleScopedCaches = GlobalSink.__warpDrive_ModuleScopedCaches ?? {};
-if (macroCondition(getGlobalConfig().WarpDrive.env.TESTING)) {
-  if (!GlobalSink.__warpDrive_ModuleScopedCaches) {
-    GlobalSink.__warpDrive_ModuleScopedCaches = ModuleScopedCaches;
-  } else {
-    // eslint-disable-next-line no-console
-    console.warn(`
-Multiple copies of WarpDrive have been detected. This may be due to a bug in ember-auto-import
-  in which test assets get their own copy of some v2-addons. This can cause the application to
-  malfunction as each copy will maintain its own separate state.`);
-  }
-} else {
-  if (GlobalSink.__warpDrive_hasOtherCopy) {
-    throw new Error('Multiple copies of WarpDrive detected, the application will malfunction.');
-  }
-  GlobalSink.__warpDrive_hasOtherCopy = true;
-}
-function getOrSetGlobal(key, value) {
-  if (macroCondition(getGlobalConfig().WarpDrive.env.TESTING)) {
-    const existing = ModuleScopedCaches[key];
-    if (existing === undefined) {
-      return ModuleScopedCaches[key] = value;
-    } else {
-      return existing;
-    }
-  } else {
-    return value;
-  }
-}
-function peekTransient(key) {
-  const globalKey = `(transient) ${key}`;
-  return ModuleScopedCaches[globalKey] ?? null;
-}
-function setTransient(key, value) {
-  const globalKey = `(transient) ${key}`;
-  return ModuleScopedCaches[globalKey] = value;
-}
-function getOrSetUniversal(key, value) {
-  if (macroCondition(getGlobalConfig().WarpDrive.env.TESTING)) {
-    const existing = UniversalCache[key];
-    if (existing === undefined) {
-      return UniversalCache[key] = value;
-    } else {
-      return existing;
-    }
-  } else {
-    return value;
-  }
-}
-function peekUniversalTransient(key) {
-  const globalKey = `(transient) ${key}`;
-  return UniversalCache[globalKey] ?? null;
-}
-function setUniversalTransient(key, value) {
-  const globalKey = `(transient) ${key}`;
-  return UniversalCache[globalKey] = value;
-}
 export { getOrSetGlobal, getOrSetUniversal, peekTransient, peekUniversalTransient, setTransient, setUniversalTransient };

package/dist/types/cache/aliases.d.ts

@@ -0,0 +1,2 @@
+import { t as ResourceBlob } from "../../aliases-BWYW5EhX.js";
+export { ResourceBlob };

package/dist/types/cache/change.d.ts

@@ -0,0 +1,2 @@
+import { t as Change } from "../../change-C7kqv2kW.js";
+export { Change };

package/dist/types/cache/mutations.d.ts

@@ -0,0 +1,2 @@
+import { a as ReplaceRelatedRecordsMutation, i as ReplaceRelatedRecordMutation, n as Mutation, o as SortRelatedRecordsMutation, r as RemoveFromResourceRelationshipMutation, t as AddToResourceRelationshipMutation } from "../../mutations-CqtoGB4t.js";
+export { AddToResourceRelationshipMutation, Mutation, RemoveFromResourceRelationshipMutation, ReplaceRelatedRecordMutation, ReplaceRelatedRecordsMutation, SortRelatedRecordsMutation };

package/dist/types/cache/operations.d.ts

@@ -0,0 +1,2 @@
+import { a as Op, c as RemoveFromDocumentOperation, d as UpdateResourceFieldOperation, f as UpdateResourceOperation, i as MergeOperation, l as RemoveFromResourceRelationshipOperation, n as AddToDocumentOperation, o as Operation, p as UpdateResourceRelationshipOperation, r as AddToResourceRelationshipOperation, s as RemoveDocumentOperation, t as AddResourceOperation, u as RemoveResourceOperation } from "../../operations-D1qA6r0_.js";
+export { AddResourceOperation, AddToDocumentOperation, AddToResourceRelationshipOperation, MergeOperation, Op, Operation, RemoveDocumentOperation, RemoveFromDocumentOperation, RemoveFromResourceRelationshipOperation, RemoveResourceOperation, UpdateResourceFieldOperation, UpdateResourceOperation, UpdateResourceRelationshipOperation };

package/dist/types/cache/relationship.d.ts

@@ -0,0 +1,2 @@
+import { n as Relationship, r as ResourceRelationship, t as CollectionRelationship } from "../../relationship-CmHzMPKf.js";
+export { CollectionRelationship, Relationship, ResourceRelationship };

package/dist/types/cache.d.ts

@@ -0,0 +1,2 @@
+import { Gt as Cache, Kt as ChangedAttributesHash, qt as RelationshipDiff } from "../internal-DtWOpxrR.js";
+export { Cache, ChangedAttributesHash, RelationshipDiff };

package/dist/types/graph.d.ts

@@ -0,0 +1,2 @@
+import { a as ReplaceRelatedRecordOperation, c as UnknownOperation, i as RemoteRelationshipOperation, l as UpdateRelationshipOperation, n as LocalRelationshipOperation, o as ReplaceRelatedRecordsOperation, r as Operation, s as SortRelatedRecords, t as DeleteRecordOperation } from "../graph-DLqYXP2z.js";
+export { DeleteRecordOperation, LocalRelationshipOperation, Operation, RemoteRelationshipOperation, ReplaceRelatedRecordOperation, ReplaceRelatedRecordsOperation, SortRelatedRecords, UnknownOperation, UpdateRelationshipOperation };

package/dist/types/identifier.d.ts

@@ -0,0 +1,2 @@
+import { a as DEBUG_STALE_CACHE_OWNER, c as RequestKey, d as StableExistingRecordIdentifier, f as StableRecordIdentifier, i as DEBUG_KEY_TYPE, l as ResourceKey, n as CacheKeyType, o as NewResourceKey, r as DEBUG_CLIENT_ORIGINATED, s as PersistedResourceKey, t as CACHE_OWNER, u as StableDocumentIdentifier } from "../identifier-DQnqOSJK.js";
+export { CACHE_OWNER, CacheKeyType, DEBUG_CLIENT_ORIGINATED, DEBUG_KEY_TYPE, DEBUG_STALE_CACHE_OWNER, NewResourceKey, PersistedResourceKey, RequestKey, ResourceKey, StableDocumentIdentifier, StableExistingRecordIdentifier, StableRecordIdentifier };

package/dist/types/identifier.js

@@ -1,63 +1,71 @@
-import { macroCondition, getGlobalConfig } from '@embroider/macros';
+import { getGlobalConfig, macroCondition } from "@embroider/macros";
 
-// provided for additional debuggability
-const DEBUG_CLIENT_ORIGINATED = Symbol('record-originated-on-client');
-const DEBUG_KEY_TYPE = Symbol('key-type');
-const DEBUG_STALE_CACHE_OWNER = Symbol('warpDriveStaleCache');
+//#region src/types/identifier.ts
+/**
+* @private
+*/
+const DEBUG_CLIENT_ORIGINATED = Symbol("record-originated-on-client");
+/**
+* @private
+*/
+const DEBUG_KEY_TYPE = Symbol("key-type");
+/**
+* @private
+*/
+const DEBUG_STALE_CACHE_OWNER = Symbol("warpDriveStaleCache");
 function ProdSymbol(str, debugStr) {
-  return macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? Symbol(debugStr) : str;
+	return macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? Symbol(debugStr) : str;
 }
-
-// also present in production
-const CACHE_OWNER = ProdSymbol('__$co', 'CACHE_OWNER');
-
 /**
- * A referentially stable object with a unique string (lid) that can be used
- * as a reference to request data in the cache.
- *
- * Only requests that are assigned a RequestKey are retrievable/replayable from
- * the cache, though requests without RequestKeys may still update cache state.
- *
- * @public
- */
-
+* @private
+*/
+const CACHE_OWNER = ProdSymbol("__$co", "CACHE_OWNER");
+/**
+* Identifies which "bucket" of the cache a key belongs to: resources
+* (`'record'`, see {@link ResourceKey}) or request documents
+* (`'document'`, see {@link RequestKey}).
+*/
+/**
+* A referentially stable object with a unique string (lid) that can be used
+* as a reference to request data in the cache.
+*
+* Only requests that are assigned a RequestKey are retrievable/replayable from
+* the cache, though requests without RequestKeys may still update cache state.
+*
+* @public
+*/
 /** @deprecated use {@link RequestKey} */
-
 /**
- * Used when an ResourceKey is known to be the stable version
- */
-
+* Used when an ResourceKey is known to be the stable version
+*/
 /**
- * Used when a ResourceKey was not created locally as part
- * of a call to store.createRecord
- *
- * Distinguishing between this ResourceKey and one for a client created
- * resource that was created with an ID is generally speaking not possible
- * at runtime, so anything with an ID typically narrows to this.
- */
-
+* Used when a ResourceKey was not created locally as part
+* of a call to store.createRecord
+*
+* Distinguishing between this ResourceKey and one for a client created
+* resource that was created with an ID is generally speaking not possible
+* at runtime, so anything with an ID typically narrows to this.
+*/
 /** @deprecated use {@link PersistedResourceKey} */
-
 /**
- * Used when a ResourceKey was created locally
- * (by a call to store.createRecord).
- *
- * It is possible in rare circumstances to have a ResourceKey
- * that is not for a new record but does not have an ID. This would
- * happen if a user intentionally created one for use with a secondary-index
- * prior to the record having been fully loaded.
- */
-
+* Used when a ResourceKey was created locally
+* (by a call to store.createRecord).
+*
+* It is possible in rare circumstances to have a ResourceKey
+* that is not for a new record but does not have an ID. This would
+* happen if a user intentionally created one for use with a secondary-index
+* prior to the record having been fully loaded.
+*/
 /**
- * A referentially stable object with a unique string (lid) that can be used
- * as a reference to data in the cache.
- *
- * Every resource has a unique ResourceKey, and ResourceKeys may refer
- * to data that has never been loaded (for instance, in an async relationship).
- *
- * @public
- */
-
+* A referentially stable object with a unique string (lid) that can be used
+* as a reference to data in the cache.
+*
+* Every resource has a unique ResourceKey, and ResourceKeys may refer
+* to data that has never been loaded (for instance, in an async relationship).
+*
+* @public
+*/
 /** @deprecated use {@link ResourceKey} */
-
-export { CACHE_OWNER, DEBUG_CLIENT_ORIGINATED, DEBUG_KEY_TYPE, DEBUG_STALE_CACHE_OWNER };
+//#endregion
+export { CACHE_OWNER, DEBUG_CLIENT_ORIGINATED, DEBUG_KEY_TYPE, DEBUG_STALE_CACHE_OWNER };
+//# sourceMappingURL=identifier.js.map

package/dist/types/identifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"identifier.js","names":["getGlobalConfig","macroCondition","DEBUG_CLIENT_ORIGINATED","Symbol","DEBUG_KEY_TYPE","DEBUG_STALE_CACHE_OWNER","ProdSymbol","str","debugStr","WarpDrive","env","DEBUG","CACHE_OWNER"],"sources":["../../src/types/identifier.ts"],"sourcesContent":["import { DEBUG } from '@warp-drive/core/build-config/env';\n\n// provided for additional debuggability\n/**\n * @private\n */\nexport const DEBUG_CLIENT_ORIGINATED: unique symbol = Symbol('record-originated-on-client');\n/**\n * @private\n */\nexport const DEBUG_KEY_TYPE: unique symbol = Symbol('key-type');\n/**\n * @private\n */\nexport const DEBUG_STALE_CACHE_OWNER: unique symbol = Symbol('warpDriveStaleCache');\n\nfunction ProdSymbol<T extends string>(str: T, debugStr: string): T {\n  return DEBUG ? (Symbol(debugStr) as unknown as T) : str;\n}\n\n// also present in production\n/**\n * @private\n */\nexport const CACHE_OWNER: '__$co' = ProdSymbol('__$co', 'CACHE_OWNER');\n\n/**\n * Identifies which \"bucket\" of the cache a key belongs to: resources\n * (`'record'`, see {@link ResourceKey}) or request documents\n * (`'document'`, see {@link RequestKey}).\n */\nexport type CacheKeyType = 'record' | 'document';\n\n/**\n * A referentially stable object with a unique string (lid) that can be used\n * as a reference to request data in the cache.\n *\n * Only requests that are assigned a RequestKey are retrievable/replayable from\n * the cache, though requests without RequestKeys may still update cache state.\n *\n * @public\n */\nexport interface RequestKey {\n  /**\n   * A string representing a unique identity.\n   */\n  lid: string;\n  /**\n   * Discriminates a {@link RequestKey} from a {@link ResourceKey}.\n   */\n  type: '@document';\n  /** @internal */\n  [CACHE_OWNER]: number | undefined;\n}\n\n/** @deprecated use {@link RequestKey} */\nexport type StableDocumentIdentifier = RequestKey;\n\n/**\n * Used when an ResourceKey is known to be the stable version\n */\ninterface ResourceKeyBase<T extends string = string> {\n  /**\n   * A string representing a unique identity.\n   *\n   * @public\n   */\n  lid: string;\n\n  /**\n   * the primary `ResourceType` or \"model name\" this ResourceKey belongs to.\n   *\n   * @public\n   */\n  type: T;\n\n  /** @internal */\n  [CACHE_OWNER]: number | undefined;\n\n  /** @internal */\n  [DEBUG_CLIENT_ORIGINATED]?: boolean;\n  /** @internal */\n  [DEBUG_STALE_CACHE_OWNER]?: number | undefined;\n}\n\n/**\n * Used when a ResourceKey was not created locally as part\n * of a call to store.createRecord\n *\n * Distinguishing between this ResourceKey and one for a client created\n * resource that was created with an ID is generally speaking not possible\n * at runtime, so anything with an ID typically narrows to this.\n */\nexport interface PersistedResourceKey<T extends string = string> extends ResourceKeyBase<T> {\n  /**\n   * the PrimaryKey for the resource this ResourceKey represents.\n   *\n   * @public\n   */\n  id: string;\n}\n\n/** @deprecated use {@link PersistedResourceKey} */\nexport type StableExistingRecordIdentifier<T extends string = string> = PersistedResourceKey<T>;\n\n/**\n * Used when a ResourceKey was created locally\n * (by a call to store.createRecord).\n *\n * It is possible in rare circumstances to have a ResourceKey\n * that is not for a new record but does not have an ID. This would\n * happen if a user intentionally created one for use with a secondary-index\n * prior to the record having been fully loaded.\n */\nexport interface NewResourceKey<T extends string = string> extends ResourceKeyBase<T> {\n  /**\n   * the PrimaryKey for the resource this ResourceKey represents. `null`\n   * if not yet assigned a PrimaryKey value.\n   *\n   * @public\n   */\n  id: string | null;\n}\n\n/**\n * A referentially stable object with a unique string (lid) that can be used\n * as a reference to data in the cache.\n *\n * Every resource has a unique ResourceKey, and ResourceKeys may refer\n * to data that has never been loaded (for instance, in an async relationship).\n *\n * @public\n */\nexport type ResourceKey<T extends string = string> = PersistedResourceKey<T> | NewResourceKey<T>;\n\n/** @deprecated use {@link ResourceKey} */\nexport type StableRecordIdentifier<T extends string = string> = ResourceKey<T>;\n"],"mappings":";;;;;;AAMA,MAAaE,0BAAyCC,OAAO,6BAA6B;;;;AAI1F,MAAaC,iBAAgCD,OAAO,UAAU;;;;AAI9D,MAAaE,0BAAyCF,OAAO,qBAAqB;AAElF,SAASG,WAA6BC,KAAQC,UAAqB;CACjE,OAAOP,eAAAD,gBAAA,CAAA,CAAAS,UAAAC,IAAAC,KAAA,IAASR,OAAOK,QAAQ,IAAqBD;AACtD;;;;AAMA,MAAaK,cAAuBN,WAAW,SAAS,aAAa"}

package/dist/types/json/raw.d.ts

@@ -0,0 +1,2 @@
+import { i as Value, n as ObjectValue, r as PrimitiveValue, t as ArrayValue } from "../../raw-D5hnjiq7.js";
+export { ArrayValue, ObjectValue, PrimitiveValue, Value };

package/dist/types/params.d.ts

@@ -0,0 +1,2 @@
+import { i as SerializablePrimitive, n as QueryParamsSource, r as Serializable, t as QueryParamsSerializationOptions } from "../params-DrEx3bf8.js";
+export { QueryParamsSerializationOptions, QueryParamsSource, Serializable, SerializablePrimitive };

package/dist/types/record.d.ts

@@ -0,0 +1,2 @@
+import { a as StringSatisfiesIncludes, c as TypedRecordInstance, i as OpaqueRecordInstance, l as Validate, n as Includes, o as TypeFromInstance, r as Mask, s as TypeFromInstanceOrString, t as ExtractSuggestedCacheTypes, u as createIncludeValidator } from "../record-D3QQcaIR.js";
+export { ExtractSuggestedCacheTypes, Includes, Mask, OpaqueRecordInstance, StringSatisfiesIncludes, TypeFromInstance, TypeFromInstanceOrString, TypedRecordInstance, Validate, createIncludeValidator };