@warp-drive/core 5.6.0-alpha.17 → 5.6.0-alpha.5

package/declarations/store/-private/utils/coerce-id.d.ts

@@ -1,10 +0,0 @@
-// 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

@@ -1,6 +0,0 @@
-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

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

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

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

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

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

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

@@ -1,31 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,23 +0,0 @@
-/**
-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

@@ -1,354 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

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

package/declarations/utils/string.d.ts

@@ -1,48 +0,0 @@
-/**
-* An LRUCache implementation with upsert semantics.
-*
-* This implementation is *not* generic, but focuses on
-* performance tuning for the string transformation cases
-* where the key maps to the value very simply.
-*
-* It takes a work function that should generate a new value
-* for a given key when called. It will be called when the key
-* is not found in the cache.
-*
-* It keeps track of the number of hits, misses, and ejections
-* in DEBUG envs, which is useful for tuning the cache size.
-*
-* This is an internal utility class for use by this module
-* and by `@warp-drive/utilities/string`. It is not intended
-* for use outside of these modules at this time.
-*
-* @internal
-*/
-export declare class LRUCache<
-	T,
-	V
-> {
-	size: number;
-	state: Map<T, V>;
-	doWork: (k: T) => V;
-	// debug stats
-	_hits: number;
-	_misses: number;
-	_ejected: number;
-	constructor(doWork: (k: T) => V, size?: number);
-	get(key: T): V;
-	set(key: T, value: V): void;
-	clear(): void;
-}
-export declare const STRING_DASHERIZE_CACHE: LRUCache<string, string>;
-/**
-* This is an internal utility function that converts a string
-* to a dasherized format. Library consumers should use the
-* re-exported version from `@warp-drive/utilities/string` instead.
-*
-* This version is only in this location to support a deprecated
-* behavior in the core package and will be removed in a future.
-*
-* @internal
-*/
-export declare function dasherize(str: string): string;

package/dist/build-config/babel-macros.js

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

package/dist/build-config/canary-features.js

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

package/dist/build-config/debugging.js

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