@warp-drive/legacy 5.9.0-alpha.2 → 5.9.0-alpha.21

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

@@ -278,9 +278,9 @@ interface Model {
 	for a given relationship will always return the same HasManyReference.
 	
 	@public
-	@param {String} name of the relationship
+	@param prop - the name of the relationship
 	@since 2.5.0
-	@return {BelongsToReference} reference for this relationship
+	@return reference for this relationship
 	*/
 	belongsTo<
 		T extends Model,
@@ -331,9 +331,9 @@ interface Model {
 	for a given relationship will always return the same HasManyReference.
 	
 	@public
-	@param {String} name of the relationship
+	@param prop - the name of the relationship
 	@since 2.5.0
-	@return {HasManyReference} reference for this relationship
+	@return reference for this relationship
 	*/
 	hasMany<
 		T extends MinimalLegacyRecord,
@@ -605,6 +605,9 @@ declare class Model extends EmberObject implements MinimalLegacyRecord {
 	@public
 	*/
 	get isError(): boolean;
+	/**
+	* `isError` is read-only and cannot be set directly.
+	*/
 	set isError(v: boolean);
 	/**
 	If `true` the store is attempting to reload the record from the adapter.
@@ -638,12 +641,19 @@ declare class Model extends EmberObject implements MinimalLegacyRecord {
 	@public
 	*/
 	get id(): string | null;
+	/**
+	* Assigns the resource's primary key. Typically only used internally
+	* when a client-created record is assigned an id upon being saved.
+	*/
 	set id(id: string | null);
 	toString(): string;
 	/**
 	@private
 	*/
 	get currentState(): RecordState;
+	/**
+	* `currentState` is read-only and cannot be set directly.
+	*/
 	set currentState(_v: RecordState);
 	/**
 	The store service instance which created this record instance
@@ -709,6 +719,9 @@ declare class Model extends EmberObject implements MinimalLegacyRecord {
 	@public
 	*/
 	get adapterError(): unknown;
+	/**
+	* `adapterError` is read-only and cannot be set directly.
+	*/
 	set adapterError(v: unknown);
 	notifyPropertyChange(prop: string): this;
 	/**
@@ -764,8 +777,22 @@ declare class Model extends EmberObject implements MinimalLegacyRecord {
 	@param binding the value to which the callback's `this` should be bound
 	*/
 	eachRelationship<T>(callback: (this: NoInfer<T> | undefined, key: MaybeRelationshipFields<this>, meta: LegacyRelationshipField) => void, binding?: T): void;
+	/**
+	* Returns the relationship schema for the given relationship name, if any.
+	*/
 	relationshipFor(name: string): LegacyRelationshipField | undefined;
+	/**
+	* Returns the inverse relationship schema for the given relationship
+	* name, if one exists. See {@link Model.inverseFor | the static inverseFor}.
+	*/
 	inverseFor(name: string): LegacyRelationshipField | null;
+	/**
+	* Iterates over the attributes defined on this record's class, calling
+	* `callback` for each one. See {@link Model.eachAttribute | the static eachAttribute}.
+	*
+	* @param callback the callback to invoke
+	* @param binding the value to which the callback's `this` should be bound
+	*/
 	eachAttribute<T>(callback: (this: NoInfer<T> | undefined, key: isSubClass<this> extends true ? MaybeAttrFields<this> : string, meta: LegacyAttributeField) => void, binding?: T): void;
 	/**
 	Represents the model's class name as a string. This can be used to look up the model's class name through
@@ -817,6 +844,10 @@ declare class Model extends EmberObject implements MinimalLegacyRecord {
 	@return the type of the relationship, or undefined
 	*/
 	static typeForRelationship(name: string, store: Store): ModelSchema | undefined;
+	/**
+	* A cache of resolved inverse relationships by name, populated lazily by
+	* {@link Model.inverseFor | inverseFor}.
+	*/
 	static get inverseMap(): Record<string, LegacyRelationshipField | null>;
 	/**
 	Find the relationship which is the inverse of the one asked for.
@@ -850,6 +881,9 @@ declare class Model extends EmberObject implements MinimalLegacyRecord {
 	@return the inverse relationship, or null
 	*/
 	static inverseFor(name: string, store: Store): LegacyRelationshipField | null;
+	/**
+	* @private
+	*/
 	static _findInverseFor(name: string, store: Store): LegacyRelationshipField | null;
 	/**
 	The model's relationships as a map, keyed on the type of the
@@ -919,7 +953,13 @@ declare class Model extends EmberObject implements MinimalLegacyRecord {
 	@public
 	*/
 	static get relationshipNames(): {
+		/**
+		* the names of the model's `hasMany` relationships
+		*/
 		hasMany: string[];
+		/**
+		* the names of the model's `belongsTo` relationships
+		*/
 		belongsTo: string[];
 	};
 	/**
@@ -985,6 +1025,11 @@ declare class Model extends EmberObject implements MinimalLegacyRecord {
 	@public
 	*/
 	static get relationshipsByName(): Map<string, LegacyRelationshipField>;
+	/**
+	* A hash of the model's relationship schemas keyed by relationship name.
+	* See also {@link Model.relationshipsByName | relationshipsByName}, which
+	* provides the same information as a `Map`.
+	*/
 	static get relationshipsObject(): Record<string, LegacyRelationshipField>;
 	/**
 	A map whose keys are the fields of the model and whose values are strings
@@ -1224,5 +1269,11 @@ declare class Model extends EmberObject implements MinimalLegacyRecord {
 	*/
 	static toString(): string;
 }
+/**
+* Restores the pre-`RequestManager` implementations of `save`,
+* `destroyRecord`, and `reload` onto the given `Model` subclass, for
+* apps that have not yet migrated off of the deprecated
+* `ENABLE_LEGACY_REQUEST_METHODS` behaviors.
+*/
 export declare function restoreDeprecatedModelRequestBehaviors(ModelKlass: typeof Model): void;
 export { Model };

package/declarations/model/-private/promise-many-array.d.ts

@@ -7,11 +7,15 @@ export interface HasManyProxyCreateArgs<T = unknown> {
 	content?: ManyArray<T>;
 }
 export interface PromiseManyArray<T> {
+	/**
+	* A property signifying that this object implements the classic Ember
+	* `PromiseProxyMixin`-like API. See {@link LegacyPromiseProxy}.
+	*/
 	[LegacyPromiseProxy]: true;
 }
 /**
 This class is returned as the result of accessing an async hasMany relationship
-on an instance of a Model extending from `@ember-data/model`.
+on an instance of a Model extending from `@warp-drive/legacy/model`.
 
 A PromiseManyArray is an iterable proxy that allows templates to consume related
 ManyArrays and update once their contents are no longer pending.
@@ -25,8 +29,19 @@ const comments = await post.comments;
 @public
 */
 export declare class PromiseManyArray<T = unknown> {
+	/**
+	* The promise for the relationship's content, or `null` once
+	* {@link PromiseManyArray.destroy | destroy} has been called.
+	*/
 	promise: Promise<ManyArray<T>> | null;
+	/**
+	* Whether {@link PromiseManyArray.destroy | destroy} has been called.
+	*/
 	isDestroyed: boolean;
+	/**
+	* The resolved `ManyArray` for the relationship, if the promise has
+	* resolved, else `null`.
+	*/
 	content: ManyArray<T> | null;
 	constructor(promise: Promise<ManyArray<T>>, content?: ManyArray<T>);
 	/**
@@ -34,6 +49,9 @@ export declare class PromiseManyArray<T = unknown> {
 	* @public
 	*/
 	get length(): number;
+	/**
+	* @private
+	*/
 	get "[]"(): 0 | ManyArray<T> | undefined;
 	/**
 	* Iterate the proxied content. Called by the glimmer iterator in #each
@@ -91,6 +109,12 @@ export declare class PromiseManyArray<T = unknown> {
 	* @public
 	*/
 	finally(cb: Parameters<Promise<ManyArray<T>>["finally"]>[0]): Promise<unknown>;
+	/**
+	* Tears down this proxy, releasing its {@link PromiseManyArray.content | content} and
+	* {@link PromiseManyArray.promise | promise} and marking it as {@link PromiseManyArray.isDestroyed | destroyed}.
+	*
+	* @public
+	*/
 	destroy(): void;
 	/**
 	* Retrieve the links for this relationship

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

@@ -3,7 +3,7 @@ import type { SchemaService } from "@warp-drive/core/types";
 import type { ResourceKey } from "@warp-drive/core/types/identifier";
 import type { ObjectValue } from "@warp-drive/core/types/json/raw";
 import type { Derivation, HashFn, Transformation } from "@warp-drive/core/types/schema/concepts";
-import type { ArrayField, DerivedField, GenericField, HashField, LegacyField, ObjectField, ObjectSchema, ResourceSchema } from "@warp-drive/core/types/schema/fields";
+import type { ArrayField, CacheableFieldSchema, DerivedField, GenericField, HashField, IdentityField, LegacyField, ObjectField, ObjectSchema, ResourceSchema } from "@warp-drive/core/types/schema/fields";
 import type { ModelFactory, ModelStore } from "./model.js";
 type AttributesSchema = ReturnType<Exclude<SchemaService["attributesDefinitionFor"], undefined>>;
 type RelationshipsSchema = ReturnType<Exclude<SchemaService["relationshipsDefinitionFor"], undefined>>;
@@ -47,10 +47,20 @@ export declare class ModelSchemaProvider implements SchemaService {
 	fields(resource: ResourceKey | {
 		type: string;
 	}): Map<string, LegacyField>;
+	cacheFields(resource: ResourceKey | {
+		type: string;
+	}): Map<string, Exclude<CacheableFieldSchema, IdentityField>>;
 	hasResource(resource: {
 		type: string;
 	}): boolean;
 }
+/**
+* The `createSchemaService` implementation for use with `Model`. Pass
+* the result of this to your store's `createSchemaService` method when
+* configuring the store to use `Model` for schema information.
+*
+* @public
+*/
 export declare function buildSchema(store: Store): SchemaService;
 export declare function getModelFactory(store: ModelStore, type: string): ModelFactory | null;
 export {};

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

@@ -1,6 +1,6 @@
 import type { Store } from "@warp-drive/core";
 import type { CAUTION_MEGA_DANGER_ZONE_Extension, ProcessedExtension } from "@warp-drive/core/reactive";
-import type { ExtensibleField } from "@warp-drive/core/reactive/-private/schema";
+import type { ExtensibleField } from "@warp-drive/core/reactive/-private";
 import type { SchemaService } from "@warp-drive/core/types";
 import type { ChangedAttributesHash } from "@warp-drive/core/types/cache";
 import type { ResourceKey } from "@warp-drive/core/types/identifier";
@@ -16,8 +16,19 @@ import RecordState from "./-private/record-state.js";
 import type BelongsToReference from "./-private/references/belongs-to.js";
 import type HasManyReference from "./-private/references/has-many.js";
 import type { _MaybeBelongsToFields, MaybeHasManyFields } from "./-private/type-utils.js";
+/**
+* Adds the `Model`-style `belongsTo`/`hasMany` reference methods to a
+* {@link TypedRecordInstance}, for use when migrating a resource from
+* `Model` to a schema-based record while preserving these APIs.
+*/
 export type WithLegacyDerivations<T extends TypedRecordInstance> = T & MinimalLegacyRecord & {
+	/**
+	* see {@link belongsTo}
+	*/
 	belongsTo: typeof belongsTo;
+	/**
+	* see {@link hasMany}
+	*/
 	hasMany: typeof hasMany;
 };
 type AttributesSchema = ReturnType<Exclude<SchemaService["attributesDefinitionFor"], undefined>>;
@@ -214,16 +225,35 @@ export declare function registerDerivations(schema: SchemaService): void;
 * @public
 */
 export interface DelegatingSchemaService {
+	/**
+	* Delegates to whichever of the primary/fallback schema services has a
+	* schema for the resource, preferring the primary. See {@link DelegatingSchemaService.isDelegated | isDelegated}.
+	*/
 	attributesDefinitionFor?(resource: ResourceKey | {
 		type: string;
 	}): AttributesSchema;
+	/**
+	* Delegates to whichever of the primary/fallback schema services has a
+	* schema for the resource, preferring the primary. See {@link DelegatingSchemaService.isDelegated | isDelegated}.
+	*/
 	relationshipsDefinitionFor?(resource: ResourceKey | {
 		type: string;
 	}): RelationshipsSchema;
+	/**
+	* Whether either the primary or fallback schema service has a schema
+	* for the given type.
+	*/
 	doesTypeExist?(type: string): boolean;
 }
+/**
+* See the {@link DelegatingSchemaService | class documentation above} for usage.
+*/
 export declare class DelegatingSchemaService implements SchemaService {
 	constructor(store: Store, schema: SchemaService);
+	/**
+	* Whether the given resource's schema is being served by the fallback
+	* (legacy Model-derived) schema service rather than the primary one.
+	*/
 	isDelegated(resource: ResourceKey | {
 		type: string;
 	}): boolean;
@@ -273,8 +303,4 @@ 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

@@ -1,16 +1,54 @@
 import type { Fragment } from "./fragment.js";
+/**
+* The features added to an array resource by {@link FragmentArrayExtension}, providing
+* a subset of the legacy `ModelFragments` fragment-array API for migrated resources.
+*/
 export declare class FragmentArray<T extends Fragment> {
+	/**
+	* Whether this fragment array is in the process of being destroyed.
+	*/
 	isDestroying: boolean;
+	/**
+	* Whether this fragment array has been destroyed.
+	*/
 	isDestroyed: boolean;
+	/**
+	* Whether this fragment array (or any of its members) has uncommitted changes.
+	*/
 	get hasDirtyAttributes(): boolean;
+	/**
+	* Adds an existing fragment to this array, if one was given.
+	*/
 	addFragment(fragment?: T): Fragment[] | undefined;
+	/**
+	* Appends a new fragment to the end of this array, if one was given.
+	*/
 	createFragment(fragment?: T): Fragment | undefined;
+	/**
+	* Removes the given fragment from this array, if present.
+	*/
 	removeFragment(fragment?: T): void;
+	/**
+	* Reverts each member fragment's attribute back to its last known remote value.
+	*/
 	rollbackAttributes(): void;
 }
+/**
+* A schema extension that adds the {@link FragmentArray} API to migrated
+* `ModelFragments` array resources.
+*/
 export declare const FragmentArrayExtension: {
+	/**
+	* This extension applies to `'array'` schemas.
+	*/
 	kind: "array";
+	/**
+	* The registered name of this extension.
+	*/
 	name: "fragment-array";
+	/**
+	* The features ({@link FragmentArray}) added by this extension.
+	*/
 	features: typeof FragmentArray;
 };
 export default FragmentArrayExtension;

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

@@ -1,15 +1,50 @@
 import type { PrivateReactiveResource } from "@warp-drive/core/reactive/-private";
+/**
+* The features added to an object resource by {@link FragmentExtension}, providing
+* a subset of the legacy `ModelFragments` fragment API for migrated resources.
+*/
 export declare class Fragment {
+	/**
+	* Whether this fragment is in the process of being destroyed.
+	*/
 	isDestroying: boolean;
+	/**
+	* Whether this fragment has been destroyed.
+	*/
 	isDestroyed: boolean;
+	/**
+	* Whether this fragment (or the attribute it is rooted at) has uncommitted changes.
+	*/
 	get hasDirtyAttributes(): boolean;
+	/**
+	* Always `true`. Used to distinguish fragments from other resources.
+	*/
 	get isFragment(): boolean;
+	/**
+	* The resource type of this fragment, if known.
+	*/
 	get $type(): string | null | undefined;
+	/**
+	* Reverts this fragment's attribute back to its last known remote value.
+	*/
 	rollbackAttributes(this: PrivateReactiveResource): void;
 }
+/**
+* A schema extension that adds the {@link Fragment} API to migrated
+* `ModelFragments` object resources.
+*/
 export declare const FragmentExtension: {
+	/**
+	* This extension applies to `'object'` schemas.
+	*/
 	kind: "object";
+	/**
+	* The registered name of this extension.
+	*/
 	name: "fragment";
+	/**
+	* The features ({@link Fragment}) added by this extension.
+	*/
 	features: typeof Fragment;
 };
 export default FragmentExtension;

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

@@ -16,5 +16,12 @@ export declare class ShimModelClass<T = unknown> implements ModelSchema<T> {
 	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>;
+/**
+* The `modelFor` fallback used to construct a `ShimModelClass` schema for a
+* type when ModelFragments support is enabled and no real `Model` subclass
+* is registered for that type.
+*
+* @public
+*/
 export declare const modelFor: typeof fragmentsModelFor;
 export {};

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

@@ -1,5 +1,13 @@
 import type { WithArrayLike, WithEmberObject } from "../compat/extensions.js";
 import type { Fragment } from "./extensions/fragment.js";
 import type { FragmentArray } from "./extensions/fragment-array.js";
+/**
+* Adds the classic `EmberObject` API (via {@link WithEmberObject}) and the
+* {@link Fragment} API to the type of a migrated single-fragment resource.
+*/
 export type WithFragment<T> = T & WithEmberObject<T> & Fragment;
+/**
+* Adds Ember's classic array-like API (via {@link WithArrayLike}) and the
+* {@link FragmentArray} API to the type of a migrated fragment-array resource.
+*/
 export type WithFragmentArray<T extends Fragment> = T & WithArrayLike<T> & FragmentArray<T>;

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

@@ -1,5 +1,11 @@
 import type ApplicationInstance from "@ember/application/instance";
 import type { SchemaService } from "@warp-drive/core/types";
+/**
+* Registers the {@link FragmentExtension}/{@link FragmentArrayExtension} schema
+* extensions on the given `SchemaService`, enabling ModelFragments migration support.
+*
+* @public
+*/
 export declare function registerFragmentExtensions(schema: SchemaService): void;
 export declare function initialize(application: ApplicationInstance): void;
 declare const _default: {

package/declarations/model-fragments/utilities/with-array-defaults.d.ts

@@ -10,17 +10,47 @@ export declare function withArrayDefaults<
 	ArrayName extends string,
 	PrimitiveType extends string
 >(arrayName: ArrayName, primitiveType?: PrimitiveType): PrimitiveType extends undefined ? {
+	/**
+	* This field is an `'array'` schema field.
+	*/
 	kind: "array";
+	/**
+	* The name of the array field.
+	*/
 	name: ArrayName;
+	/**
+	* The array's item type, `'array'` since no `primitiveType` was given.
+	*/
 	type: "array";
+	/**
+	* The schema options for this array field.
+	*/
 	options: {
+		/**
+		* The registered array-schema extensions to apply to this array.
+		*/
 		arrayExtensions: string[];
 	};
 } : {
+	/**
+	* This field is an `'array'` schema field.
+	*/
 	kind: "array";
+	/**
+	* The name of the array field.
+	*/
 	name: ArrayName;
+	/**
+	* The array's item type, derived from `primitiveType`.
+	*/
 	type: `array:${PrimitiveType}`;
+	/**
+	* The schema options for this array field.
+	*/
 	options: {
+		/**
+		* The registered array-schema extensions to apply to this array.
+		*/
 		arrayExtensions: string[];
 	};
 };

package/declarations/model-fragments/utilities/with-fragment-array-defaults.d.ts

@@ -10,11 +10,29 @@ export declare function withFragmentArrayDefaults<
 	FragmentArrayType extends string,
 	FragmentArrayName extends string
 >(fragmentArrayType: FragmentArrayType, fragmentArrayName?: FragmentArrayName): {
+	/**
+	* This field is a `'schema-array'` field, an array of fragments.
+	*/
 	kind: "schema-array";
+	/**
+	* The resource type of the fragments contained in this array.
+	*/
 	type: `fragment:${string}`;
+	/**
+	* The name of the fragment-array field.
+	*/
 	name: string;
+	/**
+	* The schema options for this fragment-array field.
+	*/
 	options: {
+		/**
+		* The registered array-schema extensions to apply to this array.
+		*/
 		arrayExtensions: string[];
+		/**
+		* Whether the array defaults to a non-null empty array when unset.
+		*/
 		defaultValue: boolean;
 	};
 };

package/declarations/model-fragments/utilities/with-fragment-defaults.d.ts

@@ -10,10 +10,25 @@ export declare function withFragmentDefaults<
 	FragmentType extends string,
 	FragmentName extends string
 >(fragmentType: FragmentType, fragmentName?: FragmentName): {
+	/**
+	* This field is a `'schema-object'` field, a single fragment.
+	*/
 	kind: "schema-object";
+	/**
+	* The resource type of the fragment.
+	*/
 	type: `fragment:${FragmentType}`;
+	/**
+	* The name of the fragment field.
+	*/
 	name: FragmentType | FragmentName;
+	/**
+	* The schema options for this fragment field.
+	*/
 	options: {
+		/**
+		* The registered object-schema extensions to apply to this fragment.
+		*/
 		objectExtensions: string[];
 	};
 };

package/declarations/model-fragments/utilities/with-legacy.d.ts

@@ -1,3 +1,11 @@
 import type { LegacyResourceSchema, ResourceSchema } from "@warp-drive/core/types/schema/fields";
 import type { WithPartial } from "@warp-drive/core/types/utils";
+/**
+* Used as a helper to setup the relevant parts of a legacy resource schema
+* migrated from `Model`, applying the `ember-object` and `fragment` object
+* extensions and a default `@id` identity field.
+*
+* @param schema the partial legacy resource schema to complete
+* @returns the completed resource schema
+*/
 export declare function withLegacy(schema: WithPartial<LegacyResourceSchema, "legacy" | "identity">): ResourceSchema;

package/declarations/serializer/-private/transforms/boolean.d.ts

@@ -1,5 +1,8 @@
 import type { TransformName } from "@warp-drive/core/types/symbols";
 export interface BooleanTransform {
+	/**
+	* see {@link TransformName}
+	*/
 	[TransformName]: "boolean";
 }
 /**
@@ -37,11 +40,21 @@ export default class UserModel extends Model {
 @public
 */
 export declare class BooleanTransform {
+	/**
+	* Converts a serialized (raw payload) value into a `boolean` (or `null`
+	* when `allowNull` is set and the value is nullish).
+	*/
 	deserialize(serialized: boolean | null | number | string, options?: {
 		allowNull?: boolean;
 	}): boolean | null;
+	/**
+	* Converts a `boolean` attribute value into its serialized (raw payload) form.
+	*/
 	serialize(deserialized: boolean | null, options?: {
 		allowNull?: boolean;
 	}): boolean | null;
+	/**
+	* Creates a new instance of this transform.
+	*/
 	static create(): BooleanTransform;
 }

package/declarations/serializer/-private/transforms/date.d.ts

@@ -1,5 +1,8 @@
 import type { TransformName } from "@warp-drive/core/types/symbols";
 export interface DateTransform {
+	/**
+	* see {@link TransformName}
+	*/
 	[TransformName]: "date";
 }
 /**
@@ -10,7 +13,7 @@ when `'date'` is passed as the type parameter to the
 standard.
 
 ```js [app/models/score.js]
-import Model, { attr, belongsTo } from '@ember-data/model';
+import Model, { attr, belongsTo } from '@warp-drive/legacy/model';
 
 export default class ScoreModel extends Model {
 @attr('number') value;
@@ -22,7 +25,18 @@ export default class ScoreModel extends Model {
 @public
 */
 export declare class DateTransform {
+	/**
+	* Converts a serialized (raw payload) `ISO 8601` string, epoch number,
+	* or nullish value into a `Date` (or `null`/`undefined`).
+	*/
 	deserialize(serialized: string | number | null, _options?: Record<string, unknown>): Date | null;
+	/**
+	* Converts a `Date` attribute value into an `ISO 8601` string, or `null`
+	* if the value is not a valid `Date`.
+	*/
 	serialize(date: Date, _options?: Record<string, unknown>): string | null;
+	/**
+	* Creates a new instance of this transform.
+	*/
 	static create(): DateTransform;
 }

package/declarations/serializer/-private/transforms/number.d.ts

@@ -1,5 +1,8 @@
 import type { TransformName } from "@warp-drive/core/types/symbols";
 export interface NumberTransform {
+	/**
+	* see {@link TransformName}
+	*/
 	[TransformName]: "number";
 }
 /**
@@ -11,7 +14,7 @@ used when `number` is passed as the type parameter to the
 Usage
 
 ```js [app/models/score.js]
-import Model, { attr, belongsTo } from '@ember-data/model';
+import Model, { attr, belongsTo } from '@warp-drive/legacy/model';
 
 export default class ScoreModel extends Model {
 @attr('number') value;
@@ -23,7 +26,17 @@ export default class ScoreModel extends Model {
 @public
 */
 export declare class NumberTransform {
+	/**
+	* Converts a serialized (raw payload) value into a `number`, or `null`
+	* if the value is empty, nullish, or not a valid number.
+	*/
 	deserialize(serialized: string | number | null | undefined, _options?: Record<string, unknown>): number | null;
+	/**
+	* Converts a `number` attribute value into its serialized (raw payload) form.
+	*/
 	serialize(deserialized: string | number | null | undefined, _options?: Record<string, unknown>): number | null;
+	/**
+	* Creates a new instance of this transform.
+	*/
 	static create(): NumberTransform;
 }