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

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

@@ -1,280 +0,0 @@
-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 { SchemaService } from "@warp-drive/core/types";
-import type { ChangedAttributesHash } from "@warp-drive/core/types/cache";
-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, 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";
-import { belongsTo, hasMany } from "./-private/model-methods.js";
-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";
-export type WithLegacyDerivations<T extends TypedRecordInstance> = T & MinimalLegacyRecord & {
-	belongsTo: typeof belongsTo;
-	hasMany: typeof hasMany;
-};
-type AttributesSchema = ReturnType<Exclude<SchemaService["attributesDefinitionFor"], undefined>>;
-type RelationshipsSchema = ReturnType<Exclude<SchemaService["relationshipsDefinitionFor"], undefined>>;
-interface LegacyModeRecord<T extends TypedRecordInstance> {
-	id: string | null;
-	serialize(options?: Record<string, unknown>): unknown;
-	destroyRecord(options?: Record<string, unknown>): Promise<this>;
-	unloadRecord(): void;
-	changedAttributes(): ChangedAttributesHash;
-	rollbackAttributes(): void;
-	_createSnapshot(): Snapshot<T>;
-	save(options?: Record<string, unknown>): Promise<this>;
-	reload(options?: Record<string, unknown>): Promise<T>;
-	belongsTo<K extends _MaybeBelongsToFields<T>>(prop: K): BelongsToReference<T, K>;
-	hasMany<K extends MaybeHasManyFields<T>>(prop: K): HasManyReference<T, K>;
-	deleteRecord(): void;
-	adapterError: unknown;
-	constructor: {
-		modelName: TypeFromInstance<T>;
-	};
-	currentState: RecordState;
-	dirtyType: "deleted" | "created" | "updated" | "";
-	errors: unknown;
-	hasDirtyAttributes: boolean;
-	isDeleted: boolean;
-	isEmpty: boolean;
-	isError: boolean;
-	isLoaded: boolean;
-	isLoading: boolean;
-	isDestroying: boolean;
-	isDestroyed: boolean;
-	isNew: boolean;
-	isSaving: boolean;
-	isValid: boolean;
-}
-/**
-* A Type utility that enables quickly adding type information for the fields
-* defined by `import { withDefaults } from '@warp-drive/legacy/model/migration-support'`.
-*
-* Example:
-*
-* ```ts
-* 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',
-*   fields: [
-*     { name: 'firstName', kind: 'attribute' },
-*     { name: 'lastName', kind: 'attribute' },
-*     { name: 'age', kind: 'attribute' },
-*     { name: 'friends',
-*       kind: 'hasMany',
-*       type: 'user',
-*       options: { inverse: 'friends', async: false }
-*     },
-*     { name: 'bestFriend',
-*       kind: 'belongsTo',
-*       type: 'user',
-*       options: { inverse: null, async: false }
-*     },
-*   ],
-* });
-*
-* export type User = WithLegacy<{
-*   firstName: string;
-*   lastName: string;
-*   age: number;
-*   friends: HasMany<User>;
-*   bestFriend: User | null;
-*   [Type]: 'user';
-* }>
-* ```
-*
-*/
-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
-* @warp-drive/legacy/model while migrating to WarpDrive.
-*
-* Example:
-*
-* ```ts
-* 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',
-*   fields: [
-*     { name: 'firstName', kind: 'attribute' },
-*     { name: 'lastName', kind: 'attribute' },
-*     { name: 'age', kind: 'attribute' },
-*     { name: 'friends',
-*       kind: 'hasMany',
-*       type: 'user',
-*       options: { inverse: 'friends', async: false }
-*     },
-*     { name: 'bestFriend',
-*       kind: 'belongsTo',
-*       type: 'user',
-*       options: { inverse: null, async: false }
-*     },
-*   ],
-* });
-*
-* export type User = WithLegacy<{
-*   firstName: string;
-*   lastName: string;
-*   age: number;
-*   friends: HasMany<User>;
-*   bestFriend: User | null;
-*   [Type]: 'user';
-* }>
-* ```
-*
-* Using this function require registering the derivations
-* it requires with the schema service.
-*
-* ```ts
-* import { registerDerivations } from '@warp-drive/legacy/model/migration-support';
-*
-* registerDerivations(schema);
-* ```
-*
-* @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;
-/**
-* Adds the necessasary fields to the schema for supporting
-* the deprecated request methods on LegacyMode schemas.
-*
-* Use this instead of `withDefaults` to add the fields
-* and behaviors necessary to support Model-Like capabilities.
-*
-* ```ts
-* 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
-*/
-export declare function registerDerivations(schema: SchemaService): void;
-/**
-* A class which provides a schema service that delegates between
-* a primary schema service and one that supports legacy model
-* classes as its schema source.
-*
-* When the primary schema service has a schema for the given
-* resource, it will be used. Otherwise, the fallback schema
-* service will be used.
-*
-* This can be used when incrementally migrating from Models to
-* ReactiveResources by enabling unmigrated Models to continue to
-* provide their own schema information to the application.
-*
-* ```ts
-* import { DelegatingSchemaService } from '@warp-drive/legacy/model/migration-support';
-* import { SchemaService } from '@warp-drive/core/reactive';
-*
-* class AppStore extends Store {
-*   createSchemaService() {
-*     const schema = new SchemaService();
-*     return new DelegatingSchemaService(this, schema);
-*   }
-* }
-* ```
-*
-* All calls to register resources, derivations, transformations, hash functions
-* etc. will be delegated to the primary schema service.
-*
-* @class DelegatingSchemaService
-* @public
-*/
-export interface DelegatingSchemaService {
-	attributesDefinitionFor?(resource: ResourceKey | {
-		type: string;
-	}): AttributesSchema;
-	relationshipsDefinitionFor?(resource: ResourceKey | {
-		type: string;
-	}): RelationshipsSchema;
-	doesTypeExist?(type: string): boolean;
-}
-export declare class DelegatingSchemaService implements SchemaService {
-	constructor(store: Store, schema: SchemaService);
-	isDelegated(resource: ResourceKey | {
-		type: string;
-	}): boolean;
-	resourceTypes(): Readonly<string[]>;
-	hasResource(resource: ResourceKey | {
-		type: string;
-	}): boolean;
-	hasTrait(type: string): boolean;
-	resourceHasTrait(resource: ResourceKey | {
-		type: string;
-	}, trait: string): boolean;
-	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;
-	hashFn(field: HashField | {
-		type: string;
-	}): HashFn;
-	derivation(field: DerivedField | {
-		type: string;
-	}): Derivation;
-	resource(resource: ResourceKey | {
-		type: string;
-	}): ResourceSchema | ObjectSchema;
-	registerResources(schemas: Array<ResourceSchema | ObjectSchema>): void;
-	registerResource(schema: ResourceSchema | ObjectSchema): void;
-	registerTransformation(transform: Transformation): void;
-	registerDerivation<
-		R,
-		T,
-		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;
-	}): null | ProcessedExtension["features"];
-	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 +0,0 @@
-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

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

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

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

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

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

@@ -1,15 +0,0 @@
-/**
-* Used as a helper to setup the relevant parts of an array
-* schema and add extensions etc.
-*
-* @param arrayName The name of the array
-* @returns The schema for an array
-*/
-export declare function withArrayDefaults<ArrayName extends string>(arrayName: ArrayName): {
-	kind: "array";
-	name: ArrayName;
-	type: `array:${string}`;
-	options: {
-		arrayExtensions: string[];
-	};
-};

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

@@ -1,20 +0,0 @@
-/**
-* Used as a helper to setup the relevant parts of a fragment-array
-* schema and add extensions etc.
-*
-* @param fragmentArrayType The type of the fragment-array
-* @param fragmentArrayName The name of the fragment-array
-* @returns The schema for a fragment-array
-*/
-export declare function withFragmentArrayDefaults<
-	FragmentArrayType extends string,
-	FragmentArrayName extends string
->(fragmentArrayType: FragmentArrayType, fragmentArrayName?: FragmentArrayName): {
-	kind: "schema-array";
-	type: `fragment:${string}`;
-	name: string;
-	options: {
-		arrayExtensions: string[];
-		defaultValue: boolean;
-	};
-};

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

@@ -1,19 +0,0 @@
-/**
-* Used as a helper to setup the relevant parts of a fragment schema
-* and add extensions etc.
-*
-* @param fragmentType The type of the fragment
-* @param fragmentName The optional name of the fragment. If not provided, it will default to the fragmentType.
-* @returns The schema for a fragment
-*/
-export declare function withFragmentDefaults<
-	FragmentType extends string,
-	FragmentName extends string
->(fragmentType: FragmentType, fragmentName?: FragmentName): {
-	kind: "schema-object";
-	type: `fragment:${FragmentType}`;
-	name: FragmentType | FragmentName;
-	options: {
-		objectExtensions: string[];
-	};
-};

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

@@ -1,3 +0,0 @@
-import type { LegacyResourceSchema, ResourceSchema } from "@warp-drive/core/types/schema/fields";
-import type { WithPartial } from "@warp-drive/core/types/utils";
-export declare function withLegacy(schema: WithPartial<LegacyResourceSchema, "legacy" | "identity">): ResourceSchema;

package/declarations/model-fragments.d.ts

@@ -1,9 +0,0 @@
-export { withArrayDefaults } from "./model-fragments/utilities/with-array-defaults.js";
-export { withFragmentDefaults } from "./model-fragments/utilities/with-fragment-defaults.js";
-export { withFragmentArrayDefaults } from "./model-fragments/utilities/with-fragment-array-defaults.js";
-export { withLegacy } from "./model-fragments/utilities/with-legacy.js";
-export { registerFragmentExtensions } from "./model-fragments/instance-initializers/fragment-extensions.js";
-export { modelFor } from "./model-fragments/hooks/model-for.js";
-export { FragmentArray, FragmentArrayExtension } from "./model-fragments/extensions/fragment-array.js";
-export { Fragment, FragmentExtension } from "./model-fragments/extensions/fragment.js";
-export type { WithFragment, WithFragmentArray } from "./model-fragments/index.js";

package/declarations/model.d.ts

@@ -1,49 +0,0 @@
-/**
-* This package provides a Presentation Model for resource data in an WarpDrive Cache.
-*
-* Models are defined as classes extending from `import Model from '@warp-drive/legacy/model';` and the
-* attributes and relationships on these classes are parsed at runtime to supply static "schema"
-* to WarpDrive's SchemaService.
-*
-* Resource data for individual resources fetched from your API is presented to the UI via instances
-* of the `Model`s you define. An instantiated `Model` is referred to as a `record`.
-
-When we refer to the `ModelClass` as opposed to a `Model` or `Record` we are referring
-specifically to the class definition and the static schema methods present on it.
-
-When we refer to a `record` we refer to a specific class instance presenting
-the resource data for a given `type` and `id`.
-
-### Defining a Model
-
-```js [app/models/person.js]
-import Model, { attr, belongsTo, hasMany } from '@warp-drive/legacy/model';
-
-export default class PersonModel extends Model {
-@attr name;
-
-@belongsTo('pet', { inverse: 'owners', async: false }) dog;
-
-@hasMany('person', { inverse: 'friends', async: true }) friends;
-}
-```
-
-### modelName convention
-
-By convention, the name of a given model (its `type`) matches the name
-of the file in the `app/models` folder and should be lowercase, singular
-and dasherized.
-
-@module
-*/
-export { attr } from "./model/-private/attr.js";
-export { belongsTo } from "./model/-private/belongs-to.js";
-export { hasMany } from "./model/-private/has-many.js";
-export { Model, restoreDeprecatedModelRequestBehaviors } from "./model/-private/model.js";
-export { Model as default } from "./model/-private/model.js";
-export type { PromiseBelongsTo as AsyncBelongsTo } from "./model/-private/promise-belongs-to.js";
-export type { PromiseManyArray as AsyncHasMany } from "./model/-private/promise-many-array.js";
-export type { RelatedCollection as ManyArray } from "@warp-drive/core/store/-private";
-export type { RelatedCollection as HasMany } from "@warp-drive/core/store/-private";
-export { instantiateRecord, teardownRecord, modelFor } from "./model/-private/hooks.js";
-export { buildSchema } from "./model/-private/schema-provider.js";

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

@@ -1,47 +0,0 @@
-import type { TransformName } from "@warp-drive/core/types/symbols";
-export interface BooleanTransform {
-	[TransformName]: "boolean";
-}
-/**
-The `BooleanTransform` class is used to serialize and deserialize
-boolean attributes on Ember Data record objects. This transform is
-used when `'boolean'` is passed as the type parameter to the
-{@link attr}function.
-
-Usage
-
-```js [app/models/user.js]
-import { Model, attr } from '@warp-drive/legacy/model';
-
-export default class UserModel extends Model {
-@attr('boolean') isAdmin;
-@attr('string') name;
-@attr('string') email;
-}
-```
-
-By default, the boolean transform only allows for values of `true` or
-`false`. You can opt into allowing `null` values for
-boolean attributes via `attr('boolean', { allowNull: true })`
-
-```js [app/models/user.js]
-import { Model, attr } from '@warp-drive/legacy/model';
-
-export default class UserModel extends Model {
-@attr('string') email;
-@attr('string') username;
-@attr('boolean', { allowNull: true }) wantsWeeklyEmail;
-}
-```
-
-@public
-*/
-export declare class BooleanTransform {
-	deserialize(serialized: boolean | null | number | string, options?: {
-		allowNull?: boolean;
-	}): boolean | null;
-	serialize(deserialized: boolean | null, options?: {
-		allowNull?: boolean;
-	}): boolean | null;
-	static create(): BooleanTransform;
-}

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

@@ -1,28 +0,0 @@
-import type { TransformName } from "@warp-drive/core/types/symbols";
-export interface DateTransform {
-	[TransformName]: "date";
-}
-/**
-The `DateTransform` class is used to serialize and deserialize
-date attributes on Ember Data record objects. This transform is used
-when `'date'` is passed as the type parameter to the
-{@link attr} function. It uses the [`ISO 8601`](https://en.wikipedia.org/wiki/ISO_8601)
-standard.
-
-```js [app/models/score.js]
-import Model, { attr, belongsTo } from '@ember-data/model';
-
-export default class ScoreModel extends Model {
-@attr('number') value;
-@belongsTo('player') player;
-@attr('date') date;
-}
-```
-
-@public
-*/
-export declare class DateTransform {
-	deserialize(serialized: string | number | null, _options?: Record<string, unknown>): Date | null;
-	serialize(date: Date, _options?: Record<string, unknown>): string | null;
-	static create(): DateTransform;
-}

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

@@ -1,29 +0,0 @@
-import type { TransformName } from "@warp-drive/core/types/symbols";
-export interface NumberTransform {
-	[TransformName]: "number";
-}
-/**
-The `NumberTransform` class is used to serialize and deserialize
-numeric attributes on Ember Data record objects. This transform is
-used when `number` is passed as the type parameter to the
-{@link attr} function.
-
-Usage
-
-```js [app/models/score.js]
-import Model, { attr, belongsTo } from '@ember-data/model';
-
-export default class ScoreModel extends Model {
-@attr('number') value;
-@belongsTo('player') player;
-@attr('date') date;
-}
-```
-
-@public
-*/
-export declare class NumberTransform {
-	deserialize(serialized: string | number | null | undefined, _options?: Record<string, unknown>): number | null;
-	serialize(deserialized: string | number | null | undefined, _options?: Record<string, unknown>): number | null;
-	static create(): NumberTransform;
-}

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

@@ -1,29 +0,0 @@
-import type { TransformName } from "@warp-drive/core/types/symbols";
-export interface StringTransform {
-	[TransformName]: "string";
-}
-/**
-The `StringTransform` class is used to serialize and deserialize
-string attributes on Ember Data record objects. This transform is
-used when `string` is passed as the type parameter to the
-{@link attr} function.
-
-Usage
-
-```js [app/models/user.js]
-import Model, { attr, belongsTo } from '@ember-data/model';
-
-export default class UserModel extends Model {
-@attr('boolean') isAdmin;
-@attr('string') name;
-@attr('string') email;
-}
-```
-
-@public
-*/
-export declare class StringTransform {
-	deserialize(serialized: unknown, _options?: Record<string, unknown>): string | null;
-	serialize(deserialized: unknown, _options?: Record<string, unknown>): string | null;
-	static create(): StringTransform;
-}