@warp-drive/legacy 5.8.0-alpha.4 → 5.8.0-alpha.40

package/declarations/compat.d.ts

@@ -6,7 +6,18 @@ import type { AdapterPayload, MinimumAdapterInterface } from "./compat/legacy-ne
 import type { MinimumSerializerInterface, SerializerOptions } from "./compat/legacy-network-handler/minimum-serializer-interface.js";
 export { LegacyNetworkHandler } from "./compat/legacy-network-handler/legacy-network-handler.js";
 export type { MinimumAdapterInterface, MinimumSerializerInterface, SerializerOptions, AdapterPayload };
+/**
+* Extends the signature of {@link Store} with additional
+* methods available when using the legacy network layer.
+*
+* @public
+* @noInheritDoc
+* @legacy
+*/
 export interface LegacyStoreCompat extends Store {
+	/**
+	* @private
+	*/
 	_fetchManager: FetchManager;
 	adapterFor(this: Store, modelName: string): MinimumAdapterInterface;
 	adapterFor(this: Store, modelName: string, _allowMissing: true): MinimumAdapterInterface | undefined;
@@ -14,13 +25,22 @@ export interface LegacyStoreCompat extends Store {
 	normalize(modelName: string, payload: ObjectValue): ObjectValue;
 	pushPayload(modelName: string, payload: ObjectValue): void;
 	serializeRecord(record: unknown, options?: SerializerOptions): unknown;
+	/**
+	* @private
+	*/
 	_adapterCache: Record<string, MinimumAdapterInterface & {
 		store: Store;
 	}>;
+	/**
+	* @private
+	*/
 	_serializerCache: Record<string, MinimumSerializerInterface & {
 		store: Store;
 	}>;
 }
+/**
+* @deprecated - use {@link LegacyStoreCompat} instead
+*/
 export type CompatStore = LegacyStoreCompat;
 /**
 Returns an instance of the adapter for a given type. For
@@ -32,8 +52,7 @@ for an `application` adapter (the default adapter for
 your entire application).
 
 @public
-@param {String} modelName
-@return {Adapter}
+@param modelName
 */
 export declare function adapterFor(this: Store, modelName: string): MinimumAdapterInterface;
 export declare function adapterFor(this: Store, modelName: string, _allowMissing: true): MinimumAdapterInterface | undefined;
@@ -50,13 +69,17 @@ If a serializer cannot be found on the adapter, it will fall back
 to an instance of `JSONSerializer`.
 
 @public
-@param {String} modelName the record to serialize
-@return {Serializer}
+@param modelName the record to serialize
 */
 export declare function serializerFor(this: Store, modelName: string): MinimumSerializerInterface | null;
 /**
-`normalize` converts a json payload into the normalized form that
-[push](../methods/push?anchor=push) expects.
+`normalize` converts a json payload into the normalized form expected by
+{@link Store.push | push} using the serializer specified by `modelName`
+
+:::warning
+Generally it would be better to invoke the serializer yourself directly,
+or write a more specialized normalization utility.
+:::
 
 Example
 
@@ -68,6 +91,7 @@ store.push(store.normalize(modelName, data));
 });
 ```
 
+@legacy
 @public
 @param modelName The name of the model type for this payload
 @return The normalized payload
@@ -83,7 +107,7 @@ All objects should be in the format expected by the
 serializer.
 
 ```js [app/serializers/application.js]
-import RESTSerializer from '@ember-data/serializer/rest';
+import RESTSerializer from '@warp-drive/legacy/serializer/rest';
 
 export default class ApplicationSerializer extends RESTSerializer;
 ```
@@ -108,13 +132,13 @@ Alternatively, `pushPayload` will accept a model type which
 will determine which serializer will process the payload.
 
 ```js [app/serializers/application.js]
-import RESTSerializer from '@ember-data/serializer/rest';
+import RESTSerializer from '@warp-drive/legacy/serializer/rest';
 
 export default class ApplicationSerializer extends RESTSerializer;
 ```
 
 ```js [app/serializers/post.js]
-import JSONSerializer from '@ember-data/serializer/json';
+import JSONSerializer from '@warp-drive/legacy/serializer/json';
 
 export default JSONSerializer;
 ```
@@ -125,8 +149,8 @@ store.pushPayload('post', pushData); // Will use the post serializer
 ```
 
 @public
-@param {String} modelName Optionally, a model type used to determine which serializer will be used
-@param {Object} inputPayload
+@param modelName Optionally, a model type used to determine which serializer will be used
+@param inputPayload
 */
 export declare function pushPayload(this: Store, modelName: string, inputPayload: ObjectValue): void;
 export declare function serializeRecord(this: Store, record: unknown, options?: SerializerOptions): unknown;

package/declarations/index.d.ts

@@ -0,0 +1,70 @@
+/**
+* @module
+* @mergeModuleWith <project>
+*/
+import { Store, type StoreSetupOptions } from "@warp-drive/core";
+import type { CacheCapabilitiesManager } from "@warp-drive/core/types";
+import type { Cache } from "@warp-drive/core/types/cache";
+import type { ObjectSchema, ResourceSchema } from "@warp-drive/core/types/schema/fields";
+interface _LegacyStoreSetupOptions<T extends Cache> extends Omit<StoreSetupOptions<T>, "schemas"> {
+	schemas?: Array<ResourceSchema | ObjectSchema>;
+	/**
+	* Whether to include support for ModelFragments migrations.
+	*/
+	modelFragments?: boolean;
+}
+export interface LegacyModelStoreSetupOptions<T extends Cache> extends _LegacyStoreSetupOptions<T> {
+	/**
+	* If true, it is presumed that no requests require use of the LegacyNetworkHandler
+	* and associated adapters/serializer methods.
+	*/
+	linksMode: true;
+	/**
+	* if true, all legacy request methods and supporting infrastructure will
+	* be available on the store.
+	*/
+	legacyRequests?: false;
+}
+export interface LegacyModelAndNetworkStoreSetupOptions<T extends Cache> extends _LegacyStoreSetupOptions<T> {
+	/**
+	* If true, it is presumed that no requests require use of the LegacyNetworkHandler
+	* and associated adapters/serializer methods.
+	*/
+	linksMode: false;
+	/**
+	* if true, all legacy request methods and supporting infrastructure will
+	* be available on the store.
+	*/
+	legacyRequests?: false;
+}
+export interface LegacyModelAndNetworkAndRequestStoreSetupOptions<T extends Cache> extends _LegacyStoreSetupOptions<T> {
+	/**
+	* If true, it is presumed that no requests require use of the LegacyNetworkHandler
+	* and associated adapters/serializer methods.
+	*/
+	linksMode: false;
+	/**
+	* if true, all legacy request methods and supporting infrastructure will
+	* be available on the store.
+	*/
+	legacyRequests: true;
+}
+export type LegacyStoreSetupOptions<T extends Cache = Cache> = LegacyModelStoreSetupOptions<T> | LegacyModelAndNetworkStoreSetupOptions<T> | LegacyModelAndNetworkAndRequestStoreSetupOptions<T>;
+export declare class ConfiguredStore<T extends {
+	cache: Cache;
+}> extends Store {
+	createCache(capabilities: CacheCapabilitiesManager): T["cache"];
+}
+/**
+* Use the legacy store with the given options.
+*/
+export declare function useLegacyStore<T extends Cache>(options: LegacyModelStoreSetupOptions<T>, StoreKlass?: typeof Store): typeof ConfiguredStore<{
+	cache: T;
+}>;
+export declare function useLegacyStore<T extends Cache>(options: LegacyModelAndNetworkStoreSetupOptions<T>, StoreKlass?: typeof Store): typeof ConfiguredStore<{
+	cache: T;
+}>;
+export declare function useLegacyStore<T extends Cache>(options: LegacyModelAndNetworkAndRequestStoreSetupOptions<T>, StoreKlass?: typeof Store): typeof ConfiguredStore<{
+	cache: T;
+}>;
+export {};

package/declarations/model/-private/attr.d.ts

@@ -75,12 +75,12 @@ export type OptionsFromInstance<T> = TypeFromInstance<T> extends never ? never :
 */
 export type DataDecorator = (target: object, key: string, desc?: DecoratorPropertyDescriptor) => void;
 /**
-`attr` defines an attribute on a [Model](/ember-data/release/classes/Model).
+`attr` defines an attribute on a {@link Model}.
 By default, attributes are passed through as-is, however you can specify an
 optional type to have the value automatically transformed.
-EmberData ships with four basic transform types: `string`, `number`,
+WarpDrive ships with four basic transform types: `string`, `number`,
 `boolean` and `date`. You can define your own transforms by subclassing
-[Transform](/ember-data/release/classes/Transform).
+{@link Transform}.
 
 Note that you cannot use `attr` to define an attribute of `id`.
 
@@ -157,9 +157,8 @@ return new this();
 ```
 
 @public
-@param {String|Object} type the attribute type
-@param {Object} options a hash of options
-@return {Attribute}
+@param type the attribute type
+@param options a hash of options
 */
 export declare function attr(): DataDecorator;
 export declare function attr<T>(type: TypeFromInstance<T>): DataDecorator;

package/declarations/model/-private/belongs-to.d.ts

@@ -15,7 +15,7 @@ export type NoNull<T> = Exclude<T, null>;
 export type RelationshipDecorator<T> = <This>(target: This, key: string, desc?: PropertyDescriptor) => void;
 /**
 `belongsTo` is used to define One-To-One and One-To-Many, and One-To-None
-relationships on a [Model](/ember-data/release/classes/Model).
+relationships on a {@link Model}.
 
 `belongsTo` takes a configuration hash as a second parameter, currently
 supported options are:
@@ -97,7 +97,7 @@ export default class Person extends Model {
 
 #### Sync vs Async Relationships
 
-EmberData fulfills relationships using resource data available in
+WarpDrive fulfills relationships using resource data available in
 the cache.
 
 Sync relationships point directly to the known related resources.
@@ -165,9 +165,8 @@ must be declared as polymorphic, and the `as` option must be used to declare the
 type each record satisfies on both sides.
 
 @public
-@param {String} type (optional) the name of the related resource
-@param {Object} options (optional) a hash of options
-@return {PropertyDescriptor} relationship
+@param type the name of the related resource
+@param options a hash of options
 */
 export declare function belongsTo(): never;
 export declare function belongsTo(type: string): never;

package/declarations/model/-private/has-many.d.ts

@@ -2,7 +2,7 @@ import type { TypeFromInstance } from "@warp-drive/core/types/record";
 import type { NoNull, RelationshipDecorator, RelationshipOptions } from "./belongs-to.js";
 /**
 `hasMany` is used to define Many-To-One and Many-To-Many, and Many-To-None
-relationships on a [Model](/ember-data/release/classes/Model).
+relationships on a {@link Model}.
 
 `hasMany` takes a configuration hash as a second parameter, currently
 supported options are:
@@ -85,7 +85,7 @@ export default class Post extends Model {
 
 #### Sync vs Async Relationships
 
-EmberData fulfills relationships using resource data available in
+WarpDrive fulfills relationships using resource data available in
 the cache.
 
 Sync relationships point directly to the known related resources.
@@ -153,9 +153,8 @@ must be declared as polymorphic, and the `as` option must be used to declare the
 type each record satisfies on both sides.
 
 @public
-@param {String} type (optional) the name of the related resource
-@param {Object} options (optional) a hash of options
-@return {PropertyDescriptor} relationship
+@param type the name of the related resource
+@param options a hash of options
 */
 export declare function hasMany(): never;
 export declare function hasMany(type: string): never;

package/declarations/model/-private/hooks.d.ts

@@ -2,7 +2,7 @@ import { type Store } from "@warp-drive/core/store/-private";
 import type { ResourceKey } from "@warp-drive/core/types/identifier";
 import type { TypeFromInstance } from "@warp-drive/core/types/record";
 import type { Model } from "./model.js";
-export declare function instantiateRecord(this: Store, identifier: ResourceKey, createRecordArgs: {
+export declare function instantiateRecord(this: Store, identifier: ResourceKey, createRecordArgs?: {
 	[key: string]: unknown;
 }): Model;
 export declare function teardownRecord(record: Model): void;

package/declarations/model/-private/legacy-relationships-support.d.ts

@@ -38,8 +38,8 @@ export declare class LegacySupport {
 	_updatePromiseProxyFor(kind: "belongsTo", key: string, args: {
 		promise: Promise<OpaqueRecordInstance | null>;
 	}): PromiseBelongsTo;
-	referenceFor(kind: "belongsTo", name: string): BelongsToReference;
-	referenceFor(kind: "hasMany", name: string): HasManyReference;
+	referenceFor(kind: "belongsTo", key: string): BelongsToReference;
+	referenceFor(kind: "hasMany", key: string): HasManyReference;
 	_findHasManyByJsonApiResource(resource: CollectionResourceRelationship, parentIdentifier: ResourceKey, relationship: CollectionEdge, options?: BaseFinderOptions): Promise<void | unknown[]> | void;
 	_findBelongsToByJsonApiResource(resource: SingleResourceRelationship, parentIdentifier: ResourceKey, relationship: ResourceEdge, options?: BaseFinderOptions): Promise<ResourceKey | null>;
 	destroy(): void;

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

@@ -28,9 +28,6 @@ export type FactoryCache = Record<string, ModelFactory>;
 export type ModelStore = Store & {
 	_modelFactoryCache: FactoryCache;
 };
-/**
-* @noInheritDoc
-*/
 interface Model {
 	/**
 	* The store service instance which created this record instance
@@ -89,8 +86,8 @@ interface Model {
 	```
 	
 	@public
-	@param {Object} options
-	@return {Promise} a promise that will be resolved when the adapter returns
+	@param options
+	@return a promise that will be resolved when the adapter returns
 	successfully or rejected if the adapter returns with an error.
 	*/
 	destroyRecord<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<this>;
@@ -204,9 +201,9 @@ interface Model {
 	}
 	```
 	
+	@deprecated use {@link Store.request} instead
 	@public
-	@param {Object} options
-	@return {Promise} a promise that will be resolved when the adapter returns
+	@return a promise that will be resolved when the adapter returns
 	successfully or rejected if the adapter returns with an error.
 	*/
 	save<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<this>;
@@ -414,7 +411,10 @@ interface Model {
 * the class to use as the reactive object for data of resource
 * of that type.
 *
+* @public
 * @noInheritDoc
+* @hideconstructor
+* @legacy
 */
 declare class Model extends EmberObject implements MinimalLegacyRecord {
 	/** @private */
@@ -797,7 +797,7 @@ declare class Model extends EmberObject implements MinimalLegacyRecord {
 	Represents the model's class name as a string. This can be used to look up the model's class name through
 	`Store`'s modelFor method.
 	
-	`modelName` is generated for you by EmberData. It will be a lowercased, dasherized string.
+	`modelName` is generated for you by WarpDrive. It will be a lowercased, dasherized string.
 	For example:
 	
 	```javascript

package/declarations/model/-private/record-state.d.ts

@@ -1,6 +1,6 @@
 import type { MinimalLegacyRecord } from "./model-methods.js";
 /**
-Historically EmberData managed a state machine
+Historically WarpDrive managed a state machine
 for each record, the localState for which
 was reflected onto Model.
 

package/declarations/model/-private/references/belongs-to.d.ts

@@ -10,11 +10,11 @@ A `BelongsToReference` is a low-level API that allows access
 and manipulation of a belongsTo relationship.
 
 It is especially useful when you're dealing with `async` relationships
-from `@ember-data/model` as it allows synchronous access to
+from `@warp-drive/legacy/model` as it allows synchronous access to
 the relationship data if loaded, as well as APIs for loading, reloading
 the data or accessing available information without triggering a load.
 
-It may also be useful when using `sync` relationships with `@ember-data/model`
+It may also be useful when using `sync` relationships with `@warp-drive/legacy/model`
 that need to be loaded/reloaded with more precise timing than marking the
 relationship as `async` and relying on autofetch would have allowed.
 
@@ -206,7 +206,7 @@ export default class BelongsToReference<
 	Example
 	
 	```js [app/models/post.js]
-	import Model, { hasMany } from '@ember-data/model';
+	import Model, { hasMany } from '@warp-drive/legacy/model';
 	
 	export default class PostModel extends Model {
 	@hasMany('comment', { async: true, inverse: null }) comments;
@@ -241,7 +241,7 @@ export default class BelongsToReference<
 	*/
 	remoteType(): "link" | "id";
 	/**
-	`push` can be used to update the data in the relationship and EmberData
+	`push` can be used to update the data in the relationship and WarpDrive
 	will treat the new data as the canonical value of this relationship on
 	the backend. A value of `null` (e.g. `{ data: null }`) can be passed to
 	clear the relationship.
@@ -430,7 +430,7 @@ export default class BelongsToReference<
 	});
 	```
 	```js [app/adapters/user.js]
-	import Adapter from '@ember-data/adapter';
+	import Adapter from '@warp-drive/legacy/adapter';
 	
 	export default class UserAdapter extends Adapter {
 	findRecord(store, type, id, snapshot) {

package/declarations/model/-private/references/has-many.d.ts

@@ -19,11 +19,11 @@ A `HasManyReference` is a low-level API that allows access
 and manipulation of a hasMany relationship.
 
 It is especially useful when you're dealing with `async` relationships
-from `@ember-data/model` as it allows synchronous access to
+from `@warp-drive/legacy/model` as it allows synchronous access to
 the relationship data if loaded, as well as APIs for loading, reloading
 the data or accessing available information without triggering a load.
 
-It may also be useful when using `sync` relationships with `@ember-data/model`
+It may also be useful when using `sync` relationships with `@warp-drive/legacy/model`
 that need to be loaded/reloaded with more precise timing than marking the
 relationship as `async` and relying on autofetch would have allowed.
 
@@ -243,7 +243,7 @@ export default class HasManyReference<
 	*/
 	meta(): Meta | null;
 	/**
-	`push` can be used to update the data in the relationship and EmberData
+	`push` can be used to update the data in the relationship and WarpDrive
 	will treat the new data as the canonical value of this relationship on
 	the backend. An empty array will signify the canonical value should be
 	empty.

package/declarations/model/migration-support.d.ts

@@ -7,7 +7,7 @@ import type { ResourceKey } from "@warp-drive/core/types/identifier";
 import type { ObjectValue } from "@warp-drive/core/types/json/raw";
 import type { TypedRecordInstance, TypeFromInstance } from "@warp-drive/core/types/record";
 import type { Derivation, HashFn, Transformation } from "@warp-drive/core/types/schema/concepts";
-import type { ArrayField, DerivedField, FieldSchema, GenericField, HashField, LegacyResourceSchema, ObjectField, ObjectSchema, ResourceSchema } from "@warp-drive/core/types/schema/fields";
+import type { ArrayField, CacheableFieldSchema, DerivedField, FieldSchema, GenericField, HashField, IdentityField, LegacyResourceSchema, ObjectField, ObjectSchema, ResourceSchema } from "@warp-drive/core/types/schema/fields";
 import type { WithPartial } from "@warp-drive/core/types/utils";
 import type { Snapshot } from "../compat/-private.js";
 import type { MinimalLegacyRecord } from "./-private/model-methods.js";
@@ -56,14 +56,14 @@ interface LegacyModeRecord<T extends TypedRecordInstance> {
 }
 /**
 * A Type utility that enables quickly adding type information for the fields
-* defined by `import { withDefaults } from '@ember-data/model/migration-support'`.
+* defined by `import { withDefaults } from '@warp-drive/legacy/model/migration-support'`.
 *
 * Example:
 *
 * ```ts
-* import { withDefaults, WithLegacy } from '@ember-data/model/migration-support';
-* import { Type } from '@warp-drive/core-types/symbols';
-* import type { HasMany } from '@ember-data/model';
+* import { withDefaults, WithLegacy } from '@warp-drive/legacy/model/migration-support';
+* import { Type } from '@warp-drive/core/types/symbols';
+* import type { HasMany } from '@@warp-drive/legacy/model';
 *
 * export const UserSchema = withDefaults({
 *   type: 'user',
@@ -99,14 +99,14 @@ export type WithLegacy<T extends TypedRecordInstance> = T & LegacyModeRecord<T>;
 /**
 * A function which adds the necessary fields to a schema and marks it as
 * being in LegacyMode. This is used to support the legacy features of
-* @ember-data/model while migrating to WarpDrive.
+* @warp-drive/legacy/model while migrating to WarpDrive.
 *
 * Example:
 *
 * ```ts
-* import { withDefaults, WithLegacy } from '@ember-data/model/migration-support';
-* import { Type } from '@warp-drive/core-types/symbols';
-* import type { HasMany } from '@ember-data/model';
+* import { withDefaults, WithLegacy } from '@warp-drive/legacy/model/migration-support';
+* import { Type } from '@warp-drive/core/types/symbols';
+* import type { HasMany } from '@warp-drive/legacy/model';
 *
 * export const UserSchema = withDefaults({
 *   type: 'user',
@@ -141,26 +141,42 @@ export type WithLegacy<T extends TypedRecordInstance> = T & LegacyModeRecord<T>;
 * it requires with the schema service.
 *
 * ```ts
-* import { registerDerivations } from '@ember-data/model/migration-support';
+* import { registerDerivations } from '@warp-drive/legacy/model/migration-support';
 *
 * registerDerivations(schema);
 * ```
 *
-* @param {LegacyResourceSchema} schema The schema to add legacy support to.
-* @return {LegacyResourceSchema} The schema with legacy support added.
+* @param schema The schema to add legacy support to.
+* @return The schema with legacy support added.
 * @public
 */
 export declare function withDefaults(schema: WithPartial<LegacyResourceSchema, "legacy" | "identity">): LegacyResourceSchema;
-export declare function withRestoredDeprecatedModelRequestBehaviors(schema: WithPartial<LegacyResourceSchema, "legacy" | "identity">): LegacyResourceSchema;
 /**
-* A function which registers the necessary derivations to support
-* the LegacyMode features of @ember-data/model while migrating to WarpDrive.
+* Adds the necessasary fields to the schema for supporting
+* the deprecated request methods on LegacyMode schemas.
 *
-* This must be called in order to use the fields added by:
+* Use this instead of `withDefaults` to add the fields
+* and behaviors necessary to support Model-Like capabilities.
 *
 * ```ts
-* import { withDefaults } from '@ember-data/model/migration-support';
+* import { withRestoredDeprecatedModelRequestBehaviors } from '@warp-drive/legacy/model/migration-support';
+*
+* export const UserSchema = withRestoredDeprecatedModelRequestBehaviors({
+*   type: 'user',
+*   fields: [
+*     { name: 'firstName', kind: 'attribute' },
+*     { name: 'lastName', kind: 'attribute' },
+*   ]
+* });
 * ```
+*/
+export declare function withRestoredDeprecatedModelRequestBehaviors(schema: WithPartial<LegacyResourceSchema, "legacy" | "identity">): LegacyResourceSchema;
+/**
+* A function which registers the necessary derivations to support
+* the LegacyMode features of @warp-drive/legacy/model while migrating to WarpDrive.
+*
+* This must be called in order to use the fields added by {@link withDefaults} or
+* {@link withRestoredDeprecatedModelRequestBehaviors}.
 *
 * @param schema The schema service to register the derivations with.
 * @public
@@ -180,8 +196,8 @@ export declare function registerDerivations(schema: SchemaService): void;
 * provide their own schema information to the application.
 *
 * ```ts
-* import { DelegatingSchemaService } from '@ember-data/model/migration-support';
-* import { SchemaService } from '@warp-drive/schema-record';
+* import { DelegatingSchemaService } from '@warp-drive/legacy/model/migration-support';
+* import { SchemaService } from '@warp-drive/core/reactive';
 *
 * class AppStore extends Store {
 *   createSchemaService() {
@@ -207,8 +223,6 @@ export interface DelegatingSchemaService {
 	doesTypeExist?(type: string): boolean;
 }
 export declare class DelegatingSchemaService implements SchemaService {
-	_preferred: SchemaService;
-	_secondary: SchemaService;
 	constructor(store: Store, schema: SchemaService);
 	isDelegated(resource: ResourceKey | {
 		type: string;
@@ -224,6 +238,9 @@ export declare class DelegatingSchemaService implements SchemaService {
 	fields(resource: ResourceKey | {
 		type: string;
 	}): Map<string, FieldSchema>;
+	cacheFields?(resource: {
+		type: string;
+	}): Map<string, Exclude<CacheableFieldSchema, IdentityField>>;
 	transformation(field: GenericField | ObjectField | ArrayField | {
 		type: string;
 	}): Transformation;
@@ -245,6 +262,10 @@ export declare class DelegatingSchemaService implements SchemaService {
 		FM extends ObjectValue | null
 	>(derivation: Derivation<R, T, FM>): void;
 	registerHashFn(hashFn: HashFn): void;
+	CAUTION_MEGA_DANGER_ZONE_hasExtension(ext: {
+		kind: "object" | "array";
+		name: string;
+	}): boolean;
 	CAUTION_MEGA_DANGER_ZONE_registerExtension(extension: CAUTION_MEGA_DANGER_ZONE_Extension): void;
 	CAUTION_MEGA_DANGER_ZONE_resourceExtensions(resource: ResourceKey | {
 		type: string;
@@ -252,4 +273,8 @@ export declare class DelegatingSchemaService implements SchemaService {
 	CAUTION_MEGA_DANGER_ZONE_objectExtensions(field: ExtensibleField, resolvedType: string | null): null | ProcessedExtension["features"];
 	CAUTION_MEGA_DANGER_ZONE_arrayExtensions(field: ExtensibleField): null | ProcessedExtension["features"];
 }
+export interface PrivateDelegatingSchemaService extends DelegatingSchemaService {
+	_preferred: SchemaService;
+	_secondary: SchemaService;
+}
 export {};

package/declarations/model-fragments/extensions/fragment-array.d.ts

@@ -0,0 +1,16 @@
+import type { Fragment } from "./fragment.js";
+export declare class FragmentArray<T extends Fragment> {
+	isDestroying: boolean;
+	isDestroyed: boolean;
+	get hasDirtyAttributes(): boolean;
+	addFragment(fragment?: T): Fragment[] | undefined;
+	createFragment(fragment?: T): Fragment | undefined;
+	removeFragment(fragment?: T): void;
+	rollbackAttributes(): void;
+}
+export declare const FragmentArrayExtension: {
+	kind: "array";
+	name: "fragment-array";
+	features: typeof FragmentArray;
+};
+export default FragmentArrayExtension;

package/declarations/model-fragments/extensions/fragment.d.ts

@@ -0,0 +1,15 @@
+import type { PrivateReactiveResource } from "@warp-drive/core/reactive/-private";
+export declare class Fragment {
+	isDestroying: boolean;
+	isDestroyed: boolean;
+	get hasDirtyAttributes(): boolean;
+	get isFragment(): boolean;
+	get $type(): string | null | undefined;
+	rollbackAttributes(this: PrivateReactiveResource): void;
+}
+export declare const FragmentExtension: {
+	kind: "object";
+	name: "fragment";
+	features: typeof Fragment;
+};
+export default FragmentExtension;

package/declarations/model-fragments/hooks/model-for.d.ts

@@ -0,0 +1,20 @@
+import type { Store } from "@warp-drive/core";
+import type { ModelSchema } from "@warp-drive/core/types";
+import type { TypedRecordInstance, TypeFromInstance } from "@warp-drive/core/types/record";
+import type { LegacyAttributeField, LegacyRelationshipField } from "@warp-drive/core/types/schema/fields";
+type KeyOrString<T> = keyof T & string extends never ? string : keyof T & string;
+export declare function getShimClass<T>(store: Store, modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string): ShimModelClass<T>;
+export declare class ShimModelClass<T = unknown> implements ModelSchema<T> {
+	__store: Store;
+	modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string;
+	constructor(store: Store, modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string);
+	get fields(): Map<KeyOrString<T>, "attribute" | "belongsTo" | "hasMany">;
+	get attributes(): Map<KeyOrString<T>, LegacyAttributeField>;
+	get relationshipsByName(): Map<KeyOrString<T>, LegacyRelationshipField>;
+	eachAttribute<K extends KeyOrString<T>>(callback: (key: K, attribute: LegacyAttributeField) => void, binding?: T): void;
+	eachRelationship<K extends KeyOrString<T>>(callback: (key: K, relationship: LegacyRelationshipField) => void, binding?: T): void;
+	eachTransformedAttribute<K extends KeyOrString<T>>(callback: (key: K, type: string | null) => void, binding?: T): void;
+}
+export declare function fragmentsModelFor<T extends TypedRecordInstance>(this: Store, modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string): ShimModelClass<T>;
+export declare const modelFor: typeof fragmentsModelFor;
+export {};

package/declarations/model-fragments/index.d.ts

@@ -0,0 +1,5 @@
+import type { WithArrayLike, WithEmberObject } from "../compat/extensions.js";
+import type { Fragment } from "./extensions/fragment.js";
+import type { FragmentArray } from "./extensions/fragment-array.js";
+export type WithFragment<T> = T & WithEmberObject<T> & Fragment;
+export type WithFragmentArray<T extends Fragment> = T & WithArrayLike<T> & FragmentArray<T>;

package/declarations/model-fragments/instance-initializers/fragment-extensions.d.ts

@@ -0,0 +1,9 @@
+import type ApplicationInstance from "@ember/application/instance";
+import type { SchemaService } from "@warp-drive/core/types";
+export declare function registerFragmentExtensions(schema: SchemaService): void;
+export declare function initialize(application: ApplicationInstance): void;
+declare const _default: {
+	name: string;
+	initialize: (application: ApplicationInstance) => void;
+};
+export default _default;