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

package/declarations/store/-private/utils/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: unknown): string | null;
+export declare function ensureStringId(id: Coercable): string;
+export {};

package/declarations/store/-private/utils/construct-resource.d.ts

@@ -0,0 +1,6 @@
+import type { ExistingResourceIdentifierObject, ResourceIdentifierObject } from "../../../types/spec/json-api-raw.js";
+export declare function constructResource(type: ResourceIdentifierObject): ResourceIdentifierObject;
+export declare function constructResource(type: string, id: string, lid: string): ExistingResourceIdentifierObject;
+export declare function constructResource(type: string | undefined, id: null | undefined, lid: string): ExistingResourceIdentifierObject;
+export declare function constructResource(type: string, id: string, lid?: string | null): ExistingResourceIdentifierObject;
+export declare function constructResource(type: string, id?: string | number | null, lid?: string | null): ResourceIdentifierObject;

package/declarations/store/-private/utils/is-non-empty-string.d.ts

@@ -0,0 +1 @@
+export declare function isNonEmptyString(str: unknown): str is string;

package/declarations/store/-private/utils/normalize-model-name.d.ts

@@ -0,0 +1 @@
+export declare function normalizeModelName(type: string): string;

package/declarations/store/-private/utils/uuid-polyfill.d.ts

@@ -0,0 +1 @@
+export default function installPolyfill(): void;

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

@@ -0,0 +1,31 @@
+export { Store, storeFor } from "./-private/store-service.js";
+export { recordIdentifierFor } from "./-private/caches/instance-cache.js";
+export { CacheHandler, type StoreRequestContext } from "./-private/cache-handler/handler.js";
+export { type CachePolicy } from "./-private/cache-handler/types.js";
+export { isStableIdentifier, isDocumentIdentifier } from "./-private/caches/identifier-cache.js";
+export { constructResource } from "./-private/utils/construct-resource.js";
+export type { InstanceCache } from "./-private/caches/instance-cache.js";
+export type { FindRecordQuery, Request, SaveRecordMutation, RequestCacheRequestState, RequestStateService } from "./-private/network/request-cache.js";
+export type { CreateRecordProperties } from "./-private/store-service.js";
+// TODO this should be a deprecated helper but we have so much usage of it
+// to also eliminate
+export { coerceId, ensureStringId } from "./-private/utils/coerce-id.js";
+export type { NativeProxy } from "./-private/record-arrays/native-proxy-type-fix.js";
+export { IdentifierArray as LiveArray, Collection as CollectionRecordArray, SOURCE, MUTATE } from "./-private/record-arrays/identifier-array.js";
+export { RecordArrayManager, fastPush } from "./-private/managers/record-array-manager.js";
+// leaked for private use / test use, should investigate removing
+export { _clearCaches } from "./-private/caches/instance-cache.js";
+export { peekCache, removeRecordDataFor } from "./-private/caches/cache-utils.js";
+// @ember-data/model needs these temporarily
+export { setRecordIdentifier, StoreMap } from "./-private/caches/instance-cache.js";
+export { setCacheFor } from "./-private/caches/cache-utils.js";
+export { normalizeModelName as _deprecatingNormalize } from "./-private/utils/normalize-model-name.js";
+export type { StoreRequestInput } from "./-private/cache-handler/handler.js";
+export { RelatedCollection } from "./-private/record-arrays/many-array.js";
+export { log, logGroup } from "./-private/debug/utils.js";
+export { getPromiseState, type PromiseState } from "./-private/new-core-tmp/promise-state.js";
+export { DISPOSE, createRequestSubscription, type SubscriptionArgs, type RequestSubscription } from "./-private/new-core-tmp/request-subscription.js";
+export { getRequestState, type RequestLoadingState, type RequestCacheRequestState as RequestState } from "./-private/new-core-tmp/request-state.js";
+export { createMemo, type SignalHooks, waitFor } from "./-private/new-core-tmp/reactivity/configure.js";
+export { memoized, gate, entangleSignal, defineSignal, defineNonEnumerableSignal } from "./-private/new-core-tmp/reactivity/signal.js";
+export { ARRAY_SIGNAL, OBJECT_SIGNAL, Signals, type WarpDriveSignal, peekInternalSignal, withSignalStore, notifyInternalSignal, consumeInternalSignal, getOrCreateInternalSignal } from "./-private/new-core-tmp/reactivity/internal.js";

package/declarations/store/-types/q/cache-capabilities-manager.d.ts

@@ -0,0 +1,99 @@
+import type { StableDocumentIdentifier, StableRecordIdentifier } from "../../../types/identifier.js";
+import type { IdentifierCache } from "../../-private/caches/identifier-cache.js";
+import type { NotificationType } from "../../-private/managers/notification-manager.js";
+import type { SchemaService } from "./schema-service.js";
+/**
+* CacheCapabilitiesManager provides encapsulated API access to the minimal
+* subset of the Store's functionality that Cache implementations
+* should interact with. It is provided to the Store's `createCache` hook.
+*
+* Cache implementations should not need more than this API provides.
+*
+* This class cannot be directly instantiated.
+*
+* @class CacheCapabilitiesManager
+* @public
+*/
+export type CacheCapabilitiesManager = {
+	/**
+	* Provides access to the IdentifierCache instance
+	* for this Store instance.
+	*
+	* The IdentifierCache can be used to peek, generate or
+	* retrieve a stable unique identifier for any resource.
+	*
+	* @property identifierCache
+	* @type {IdentifierCache}
+	* @public
+	*/
+	identifierCache: IdentifierCache;
+	/**
+	* DEPRECATED - use the schema property
+	*
+	* Provides access to the SchemaService instance
+	* for this Store instance.
+	*
+	* The SchemaService can be used to query for
+	* information about the schema of a resource.
+	*
+	* @deprecated
+	* @public
+	*/
+	getSchemaDefinitionService(): SchemaService;
+	/**
+	* Provides access to the SchemaService instance
+	* for this Store instance.
+	*
+	* The SchemaService can be used to query for
+	* information about the schema of a resource.
+	*
+	* @property schema
+	* @public
+	*/
+	schema: SchemaService;
+	/**
+	* Update the `id` for the record corresponding to the identifier
+	* This operation can only be done for records whose `id` is `null`.
+	*
+	* @param {StableRecordIdentifier} identifier;
+	* @param {String} id;
+	* @public
+	*/
+	setRecordId(identifier: StableRecordIdentifier, id: string): void;
+	/**
+	* Signal to the store that the specified record may be considered fully
+	* removed from the cache. Generally this means that not only does no
+	* data exist for the identified resource, no known relationships still
+	* point to it either.
+	*
+	* @param {StableRecordIdentifier} identifier
+	* @public
+	*/
+	disconnectRecord(identifier: StableRecordIdentifier): void;
+	/**
+	* Use this method to determine if the Store has an instantiated record associated
+	* with an identifier.
+	*
+	* @param identifier
+	* @return {Boolean}
+	* @public
+	*/
+	hasRecord(identifier: StableRecordIdentifier): boolean;
+	/**
+	* Notify subscribers of the NotificationManager that cache state has changed.
+	*
+	* `attributes` and `relationships` do not require a key, but if one is specified it
+	* is assumed to be the name of the attribute or relationship that has been updated.
+	*
+	* No other namespaces currently expect the `key` argument.
+	*
+	* @param {StableRecordIdentifier} identifier
+	* @param {'attributes' | 'relationships' | 'identity' | 'errors' | 'meta' | 'state'} namespace
+	* @param {string|undefined} key
+	* @public
+	*/
+	notifyChange(identifier: StableRecordIdentifier, namespace: "added" | "removed", key: null): void;
+	notifyChange(identifier: StableDocumentIdentifier, namespace: "added" | "updated" | "removed", key: null): void;
+	notifyChange(identifier: StableRecordIdentifier, namespace: NotificationType, key: string | null): void;
+	notifyChange(identifier: StableRecordIdentifier | StableDocumentIdentifier, namespace: NotificationType | "added" | "removed" | "updated", key: string | null): void;
+};

package/declarations/store/-types/q/ds-model.d.ts

@@ -0,0 +1,21 @@
+import type { TypedRecordInstance, TypeFromInstance } from "../../../types/record.js";
+import type { LegacyAttributeField, LegacyRelationshipField } from "../../../types/schema/fields.js";
+export type KeyOrString<T> = keyof T & string extends never ? string : keyof T & string;
+/**
+* Minimum subset of static schema methods and properties on the
+* "model" class.
+*
+* Only used when using the legacy schema-service implementation
+* for @ember-data/model or when wrapping schema for legacy
+* Adapters/Serializers.
+*
+*/
+export interface ModelSchema<T = unknown> {
+	modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string;
+	fields: Map<KeyOrString<T>, "attribute" | "belongsTo" | "hasMany">;
+	attributes: Map<KeyOrString<T>, LegacyAttributeField>;
+	relationshipsByName: Map<KeyOrString<T>, LegacyRelationshipField>;
+	eachAttribute<K extends KeyOrString<T>>(callback: (this: ModelSchema<T>, key: K, attribute: LegacyAttributeField) => void, binding?: T): void;
+	eachRelationship<K extends KeyOrString<T>>(callback: (this: ModelSchema<T>, key: K, relationship: LegacyRelationshipField) => void, binding?: T): void;
+	eachTransformedAttribute<K extends KeyOrString<T>>(callback: (this: ModelSchema<T>, key: K, type: string | null) => void, binding?: T): void;
+}

package/declarations/store/-types/q/identifier.d.ts

@@ -0,0 +1,20 @@
+import type { IdentifierBucket, StableIdentifier, StableRecordIdentifier } from "../../../types/identifier.js";
+import type { ImmutableRequestInfo } from "../../../types/request.js";
+export interface GenerationMethod {
+	(data: ImmutableRequestInfo, bucket: "document"): string | null;
+	(data: unknown | {
+		type: string;
+	}, bucket: "record"): string;
+	(data: unknown, bucket: IdentifierBucket): string | null;
+}
+export type UpdateMethod = {
+	(identifier: StableRecordIdentifier, newData: unknown, bucket: "record"): void;
+	(identifier: StableIdentifier, newData: unknown, bucket: never): void;
+};
+export type ForgetMethod = (identifier: StableIdentifier | StableRecordIdentifier, bucket: IdentifierBucket) => void;
+export type ResetMethod = () => void;
+export type KeyInfo = {
+	id: string | null;
+	type: string;
+};
+export type KeyInfoMethod = (resource: unknown, known: StableRecordIdentifier | null) => KeyInfo;

package/declarations/store/-types/q/record-instance.d.ts

@@ -0,0 +1,23 @@
+/**
+In WarpDrive, a "record instance" is a class instance used to present the data
+for a single resource, transforming the resource's cached raw data into a form
+that is useful for the application.
+
+Since every application's needs are different, WarpDrive does not assume to know
+what the shape of the record instance should be. Instead, it provides a way to
+define the record instance's via the `instantiateRecord` hook on the store.
+
+Thus for most purposes the `RecordInstance` type is "opaque" to WarpDrive, and
+should be treated as "unknown" by the library.
+
+Wherever possible, if typing an API that is consumer facing, instead of using
+OpaqueRecordInstance, we should prefer to use a generic and check if the generic
+extends `TypedRecordInstance`. This allows consumers to define their own record
+instance types and not only have their types flow through WarpDrive APIs, but
+also allows WarpDrive to provide typechecking and intellisense for the record
+based on a special symbol prsent on record instances that implement the
+`TypedRecordInstance` interface.
+
+@internal
+*/
+export type OpaqueRecordInstance = unknown;

package/declarations/store/-types/q/schema-service.d.ts

@@ -0,0 +1,354 @@
+import type { CAUTION_MEGA_DANGER_ZONE_Extension, ProcessedExtension } from "../../../reactive.js";
+import type { ExtensibleField } from "../../../reactive/-private/schema.js";
+import type { RecordIdentifier, StableRecordIdentifier } from "../../../types/identifier.js";
+import type { ObjectValue } from "../../../types/json/raw.js";
+import type { Derivation, HashFn, Transformation } from "../../../types/schema/concepts.js";
+import type { ArrayField, DerivedField, FieldSchema, GenericField, HashField, LegacyAttributeField, LegacyRelationshipField, ObjectField, Schema } from "../../../types/schema/fields.js";
+export type AttributesSchema = Record<string, LegacyAttributeField>;
+export type RelationshipsSchema = Record<string, LegacyRelationshipField>;
+interface ObjectWithStringTypeProperty {
+	type: string;
+}
+/**
+* The SchemaService provides the ability to query for information about the structure
+* of any resource type.
+*
+* Applications can provide any implementation of the SchemaService they please so long
+* as it conforms to this interface.
+*
+* The design of the service means that schema information could be lazily populated,
+* derived-on-demand, or progressively enhanced during the course of an application's runtime.
+* The primary requirement is merely that any information the service needs to correctly
+* respond to an inquest is available by the time it is asked.
+*
+* The `@ember-data/model` package provides an implementation of this service which
+* makes use of your model classes as the source of information to respond to queries
+* about resource schema. While this is useful, this may not be ideal for your application.
+* For instance, Schema information could be sideloaded or pre-flighted for API calls,
+* resulting in no need to bundle and ship potentially large and expensive JSON
+* or large Javascript based Models to pull information from.
+*
+* To register a custom schema implementation, implement the store's `createSchemaService`
+* hook to return an instance of your service.
+*
+* ```ts
+* import Store from '@ember-data/store';
+* import CustomSchemas from './custom-schemas';
+*
+* export default class extends Store {
+*   createSchemaService() {
+*     return new CustomSchemas();
+*   }
+* }
+* ```
+*
+* At runtime, both the `Store` and the `CacheCapabilitiesManager` provide
+* access to this service via the `schema` property.
+*
+* ```ts
+* export default class extends Component {
+*  @service store;
+*
+*  get fields() {
+*    return this.store
+*      .schema
+*      .fields(this.args.dataType);
+*  }
+* }
+* ```
+*
+* @class (Interface) SchemaService
+* @public
+*/
+export interface SchemaService {
+	/**
+	* DEPRECATED - use `hasResource` instead
+	*
+	* Queries whether the SchemaService recognizes `type` as a resource type
+	*
+	* @public
+	* @deprecated
+	* @param {String} type
+	* @return {Boolean}
+	*/
+	doesTypeExist?(type: string): boolean;
+	/**
+	* Queries whether the SchemaService recognizes `type` as a resource type
+	*
+	* @public
+	* @param {StableRecordIdentifier|ObjectWithStringTypeProperty} resource
+	* @return {Boolean}
+	*/
+	hasResource(resource: ObjectWithStringTypeProperty | StableRecordIdentifier): boolean;
+	/**
+	* Queries whether the SchemaService recognizes `type` as a resource trait
+	*
+	* @public
+	* @param {String} type
+	* @return {Boolean}
+	*/
+	hasTrait(type: string): boolean;
+	/**
+	* Queries whether the given resource has the given trait
+	*
+	* @public
+	* @param {StableRecordIdentifier|ObjectWithStringTypeProperty} resource
+	* @param {String} trait
+	* @return {Boolean}
+	*/
+	resourceHasTrait(resource: ObjectWithStringTypeProperty | StableRecordIdentifier, trait: string): boolean;
+	/**
+	* Queries for the fields of a given resource type or resource identity.
+	*
+	* Should error if the resource type is not recognized.
+	*
+	* @public
+	* @param {StableRecordIdentifier|ObjectWithStringTypeProperty} resource
+	* @return {Map<string, FieldSchema>}
+	*/
+	fields(resource: ObjectWithStringTypeProperty | StableRecordIdentifier): Map<string, FieldSchema>;
+	/**
+	* Returns the transformation registered with the name provided
+	* by `field.type`. Validates that the field is a valid transformable.
+	*
+	* @public
+	* @param {TransformableField|ObjectWithStringTypeProperty} field
+	* @return {Transformation}
+	*/
+	transformation(field: GenericField | ObjectField | ArrayField | ObjectWithStringTypeProperty): Transformation;
+	/**
+	* Returns the hash function registered with the name provided
+	* by `field.type`. Validates that the field is a valid HashField.
+	*
+	* @public
+	* @param {HashField|ObjectWithStringTypeProperty} field
+	* @return {HashFn}
+	*/
+	hashFn(field: HashField | ObjectWithStringTypeProperty): HashFn;
+	/**
+	* Returns the derivation registered with the name provided
+	* by `field.type`. Validates that the field is a valid DerivedField.
+	*
+	* @public
+	* @param {DerivedField|ObjectWithStringTypeProperty} field
+	* @return {Derivation}
+	*/
+	derivation(field: DerivedField | ObjectWithStringTypeProperty): Derivation;
+	/**
+	* Returns the schema for the provided resource type.
+	*
+	* @public
+	* @param {StableRecordIdentifier|ObjectWithStringTypeProperty} resource
+	* @return {ResourceSchema}
+	*/
+	resource(resource: ObjectWithStringTypeProperty | StableRecordIdentifier): Schema;
+	/**
+	* Enables registration of multiple Schemas at once.
+	*
+	* This can be useful for either pre-loading schema information
+	* or for registering schema information delivered by API calls
+	* or other sources just-in-time.
+	*
+	* @public
+	* @param {Schema[]} schemas
+	*/
+	registerResources(schemas: Schema[]): void;
+	/**
+	* Enables registration of a single Schema representing either
+	* a resource in PolarisMode or LegacyMode or an ObjectSchema
+	* representing an embedded structure in other schemas.
+	*
+	* This can be useful for either pre-loading schema information
+	* or for registering schema information delivered by API calls
+	* or other sources just-in-time.
+	*
+	* @public
+	* @param {Schema} schema
+	*/
+	registerResource(schema: Schema): void;
+	/**
+	* Enables registration of a transformation.
+	*
+	* The transformation can later be retrieved by the name
+	* attached to it's `[Type]` property.
+	*
+	* @public
+	* @param {Transformation} transform
+	*/
+	registerTransformation(transform: Transformation): void;
+	/**
+	* Enables registration of a derivation.
+	*
+	* The derivation can later be retrieved by the name
+	* attached to it's `[Type]` property.
+	*
+	* @public
+	* @param {Derivation} derivation
+	*/
+	registerDerivation<
+		R,
+		T,
+		FM extends ObjectValue | null
+	>(derivation: Derivation<R, T, FM>): void;
+	/**
+	* Enables registration of a hashing function
+	*
+	* The hashing function can later be retrieved by the name
+	* attached to it's `[Type]` property.
+	*
+	* @public
+	* @param {HashFn} hashfn
+	*/
+	registerHashFn(hashFn: HashFn): void;
+	/**
+	* DEPRECATED - use `fields` instead
+	*
+	* Returns definitions for all properties of the specified resource
+	* that are considered "attributes". Generally these are properties
+	* that are not related to book-keeping state on the client and do
+	* not represent a linkage to another resource.
+	*
+	* The return value should be a dictionary of key:value pairs
+	* where the `key` is the attribute or property's name and `value`
+	* is an object with at least the property `name` which should also
+	* match `key`.
+	*
+	* Optionally, this object may also specify `type`, which should
+	* be a string reference to a `transform`, and `options` which
+	* should be dictionary in which any key:value pairs are permissable.
+	*
+	* For instance, when using `@ember-data/model`, the following attribute
+	* definition:
+	*
+	* ```ts
+	* class extends Model {
+	*   @attr('string', { defaultValue: 'hello' }) greeting;
+	*   @attr('date') birthday;
+	*   @attr firstName;
+	* }
+	* ```
+	*
+	* Would be returned as:
+	*
+	* ```js
+	* {
+	*   greeting: { name: 'greeting', type: 'string', options: { defaultValue: 'hello' } },
+	*   birthday: { name: 'birthday', type: 'date' },
+	*   firstName: { name: 'firstName' }
+	* }
+	* ```
+	*
+	* @public
+	* @deprecated
+	* @param {RecordIdentifier|ObjectWithStringTypeProperty} identifier
+	* @return {AttributesSchema}
+	*/
+	attributesDefinitionFor?(identifier: RecordIdentifier | ObjectWithStringTypeProperty): AttributesSchema;
+	/**
+	* DEPRECATED - use `fields` instead
+	*
+	* Returns definitions for all properties of the specified resource
+	* that are considered "relationships". Generally these are properties
+	* that represent a linkage to another resource.
+	*
+	* The return value should be a dictionary of key:value pairs
+	* where the `key` is the relationship or property's name and `value`
+	* is an object with at least the following properties:
+	*
+	* - `name` which should also match the `key` used in the dictionary.
+	* - `kind` which should be either `belongsTo` or `hasMany`
+	* - `type` which should be the related resource's string "type"
+	* - `options` which should be a dictionary allowing any key but with
+	*    at least the below keys present.
+	*
+	* - `options.async` a boolean representing whether data for this relationship is
+	*      typically loaded on-demand.
+	* - `options.inverse` a string or null representing the field name / key of the
+	*       corresponding relationship on the inverse resource.
+	*
+	* Additionally the following options properties are optional. See [Polymorphic Relationships](https://rfcs.emberjs.com/id/0793-polymporphic-relations-without-inheritance)
+	*
+	* - `options.polymorphic` a boolean representing whether multiple resource types
+	*    can be used to satisfy this relationship.
+	* - `options.as` a string representing the abstract type that the concrete side of
+	*    a relationship must specify when fulfilling a polymorphic inverse.
+	*
+	* For example, the following Model using @ember-data/model would generate this relationships
+	* definition by default:
+	*
+	* ```js
+	* class User extends Model {
+	*   @belongsTo('user', { async: false, inverse: null }) bestFriend;
+	*   @hasMany('user', { async: true, inverse: 'friends' }) friends;
+	*   @hasMany('pet', { async: false, polymorphic: true, inverse: 'owner' }) pets;
+	* }
+	* ```
+	*
+	* Which would be returned as
+	*
+	* ```js
+	* {
+	*   bestFriend: {
+	*     name: 'bestFriend',
+	*     kind: 'belongsTo',
+	*     type: 'user',
+	*     options: {
+	*       async: false,
+	*       inverse: null
+	*     }
+	*   },
+	*   friends: {
+	*     name: 'friends',
+	*     kind: 'hasMany',
+	*     type: 'user',
+	*     options: {
+	*       async: true,
+	*       inverse: 'friends'
+	*     }
+	*   },
+	*   pets: {
+	*     name: 'pets',
+	*     kind: 'hasMany',
+	*     type: 'pet',
+	*     options: {
+	*       async: false,
+	*       polymorphic: true,
+	*       inverse: 'owner'
+	*     }
+	*   },
+	* }
+	* ```
+	*
+	* @public
+	* @deprecated
+	* @param {RecordIdentifier|ObjectWithStringTypeProperty} identifier
+	* @return {RelationshipsSchema}
+	*/
+	relationshipsDefinitionFor?(identifier: RecordIdentifier | ObjectWithStringTypeProperty): RelationshipsSchema;
+	/**
+	* Returns all known resource types
+	*
+	* @public
+	* @return {String[]}
+	*/
+	resourceTypes(): Readonly<string[]>;
+	/**
+	* Register an extension for either objects or arrays
+	*/
+	CAUTION_MEGA_DANGER_ZONE_registerExtension?(extension: CAUTION_MEGA_DANGER_ZONE_Extension): void;
+	/**
+	* Retrieve the extension map for a resource
+	*/
+	CAUTION_MEGA_DANGER_ZONE_resourceExtensions?(resource: StableRecordIdentifier | {
+		type: string;
+	}): null | ProcessedExtension["features"];
+	/**
+	* Retrieve the extension map for an object field
+	*/
+	CAUTION_MEGA_DANGER_ZONE_objectExtensions?(field: ExtensibleField): null | ProcessedExtension["features"];
+	/**
+	* Retrieve the extension map for an array field
+	*/
+	CAUTION_MEGA_DANGER_ZONE_arrayExtensions?(field: ExtensibleField): null | ProcessedExtension["features"];
+}
+export {};

package/declarations/store/-types/q/store.d.ts

@@ -0,0 +1,32 @@
+import type { Value } from "../../../types/json/raw.js";
+import type { Includes, TypedRecordInstance } from "../../../types/record.js";
+export interface BaseFinderOptions<T = unknown> {
+	reload?: boolean;
+	backgroundReload?: boolean;
+	include?: T extends TypedRecordInstance ? Includes<T>[] : string | string[];
+	adapterOptions?: Record<string, unknown>;
+}
+export interface FindRecordOptions<T = unknown> extends BaseFinderOptions<T> {
+	/**
+	* Data to preload into the store before the request is made.
+	* This feature is *highly* discouraged and has no corresponding
+	* feature when using builders and handlers.
+	*
+	* Excepting relationships: the data should be in the form of a
+	* JSON object where the keys are fields on the record and the value
+	* is the raw value to be added to the cache.
+	*
+	* Relationships can either be provided as string IDs from which
+	* an identifier will be built base upon the relationship's expected
+	* resource type, or be record instances from which the identifier
+	* will be extracted.
+	*
+	*/
+	preload?: Record<string, Value>;
+}
+export type QueryOptions = { [K in string | "adapterOptions"]? : K extends "adapterOptions" ? Record<string, unknown> : unknown };
+export type FindAllOptions<T = unknown> = BaseFinderOptions<T>;
+export type LegacyResourceQuery<T = unknown> = {
+	include?: T extends TypedRecordInstance ? Includes<T>[] : string | string[];
+	[key: string]: Value | undefined;
+};

package/declarations/store.d.ts

@@ -0,0 +1 @@
+export { DefaultCachePolicy, type PolicyConfig, type CacheControlValue, parseCacheControl } from "./store/-private/default-cache-policy.js";

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

@@ -1,14 +1,22 @@
-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' | 'CacheForIdentifierCache' | 'RecordCache' | 'StoreMap' | 'Store' | '$type' | 'TransformName' | 'RequestSignature' | 'IS_FUTURE' | 'DOC' | 'ManagedArrayMap' | 'ManagedObjectMap' | 'Support' | 'SOURCE' | 'MUTATE' | 'Destroy' | 'Identifier' | 'Editable' | 'EmbeddedPath' | 'EmbeddedType' | 'Parent' | 'Checkout' | 'Legacy';
+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" | "CacheForIdentifierCache" | "RecordCache" | "StoreMap" | "Store" | "$type" | "TransformName" | "RequestSignature" | "IS_FUTURE" | "DOC" | "ManagedArrayMap" | "ManagedObjectMap" | "Support" | "SOURCE" | "MUTATE" | "Destroy" | "Identifier" | "Editable" | "EmbeddedPath" | "EmbeddedField" | "Parent" | "Checkout" | "Legacy";
 type UniqueSymbol<T extends string> = `___(unique) Symbol(${T})`;
-type UniqueSymbolOr<T, K extends string> = T extends symbol ? UniqueSymbol<K> : T;
-export declare function getOrSetGlobal<T, K extends GlobalKey>(key: K, value: T): UniqueSymbolOr<T, K>;
+type UniqueSymbolOr<
+	T,
+	K extends string
+> = T extends symbol ? UniqueSymbol<K> : T;
+export declare function getOrSetGlobal<
+	T,
+	K extends GlobalKey
+>(key: K, value: T): UniqueSymbolOr<T, K>;
 export declare function peekTransient<T>(key: TransientKey): T | null;
 export declare function setTransient<T>(key: TransientKey, value: T): T;
-export declare function getOrSetUniversal<T, K extends UniversalKey>(key: K, value: T): UniqueSymbolOr<T, K>;
+export declare function getOrSetUniversal<
+	T,
+	K extends UniversalKey
+>(key: K, value: T): UniqueSymbolOr<T, K>;
 export declare function peekUniversalTransient<T>(key: UniversalTransientKey): T | null;
 export declare function setUniversalTransient<T>(key: UniversalTransientKey, value: T): T;
 export {};
-//# sourceMappingURL=-private.d.ts.map