@warp-drive/core 5.6.0-beta.1 → 5.6.0-beta.3

package/declarations/reactive/-private/document.d.ts

@@ -1,12 +1,12 @@
 import type { Store } from "../../store/-private/store-service.js";
-import type { StableDocumentIdentifier } from "../../types/identifier.js";
+import type { RequestKey } from "../../types/identifier.js";
 import type { ImmutableRequestInfo, RequestInfo } from "../../types/request.js";
 import type { ResourceDocument } from "../../types/spec/document.js";
 import type { Meta, PaginationLinks } from "../../types/spec/json-api-raw.js";
 /**
 * A Document is a class that wraps the response content from a request to the API
-* returned by `Cache.put` or `Cache.peek`, converting resource-identifiers into
-* record instances.
+* returned by `Cache.put` or `Cache.peek`, converting ResourceKeys into
+* ReactiveResource instances.
 *
 * It is not directly instantiated by the user, and its properties should not
 * be directly modified. Whether individual properties are mutable or not is
@@ -16,7 +16,6 @@ import type { Meta, PaginationLinks } from "../../types/spec/json-api-raw.js";
 * @hideconstructor
 */
 export declare class ReactiveDocument<T> {
-	#private;
 	/**
 	* The links object for this document, if any
 	*
@@ -28,8 +27,6 @@ export declare class ReactiveDocument<T> {
 	* }
 	* ```
 	*
-	* @property links
-	* @type {Object|undefined} - a links object
 	* @public
 	*/
 	readonly links?: PaginationLinks;
@@ -42,41 +39,28 @@ export declare class ReactiveDocument<T> {
 	* For collections this will be an array of record instances,
 	* for single resource requests it will be a single record instance or null.
 	*
-	* @property data
 	* @public
-	* @type {Object|Array<object>|null|undefined} - a data object
 	*/
 	readonly data?: T;
 	/**
 	* The errors returned by the API for this request, if any
 	*
-	* @property errors
 	* @public
-	* @type {Object|undefined} - an errors object
 	*/
 	readonly errors?: object[];
 	/**
 	* The meta object for this document, if any
 	*
-	* @property meta
 	* @public
-	* @type {Object|undefined} - a meta object
 	*/
 	readonly meta?: Meta;
 	/**
-	* The identifier associated with this document, if any
+	* The RequestKey associated with this document, if any
 	*
-	* @property identifier
 	* @public
-	* @type {StableDocumentIdentifier|null}
 	*/
-	readonly identifier: StableDocumentIdentifier | null;
-	protected readonly _store: Store;
-	protected readonly _localCache: {
-		document: ResourceDocument;
-		request: ImmutableRequestInfo;
-	} | null;
-	constructor(store: Store, identifier: StableDocumentIdentifier | null, localCache: {
+	readonly identifier: RequestKey | null;
+	constructor(store: Store, cacheKey: RequestKey | null, localCache: {
 		document: ResourceDocument;
 		request: ImmutableRequestInfo;
 	} | null);
@@ -89,7 +73,7 @@ export declare class ReactiveDocument<T> {
 	* @param {Object} options
 	* @return {Promise<Document>}
 	*/
-	fetch(options?: RequestInfo<ReactiveDocument<T>, T>): Promise<ReactiveDocument<T>>;
+	fetch(options?: RequestInfo<ReactiveDocument<T>>): Promise<ReactiveDocument<T>>;
 	/**
 	* Fetches the next link for this document, returning a promise that resolves
 	* with the new document when the request completes, or null  if there is no
@@ -99,7 +83,7 @@ export declare class ReactiveDocument<T> {
 	* @param {Object} options
 	* @return {Promise<Document | null>}
 	*/
-	next(options?: RequestInfo<ReactiveDocument<T>, T>): Promise<ReactiveDocument<T> | null>;
+	next(options?: RequestInfo<ReactiveDocument<T>>): Promise<ReactiveDocument<T> | null>;
 	/**
 	* Fetches the prev link for this document, returning a promise that resolves
 	* with the new document when the request completes, or null if there is no
@@ -109,7 +93,7 @@ export declare class ReactiveDocument<T> {
 	* @param {Object} options
 	* @return {Promise<Document | null>}
 	*/
-	prev(options: RequestInfo<ReactiveDocument<T>, T>): Promise<ReactiveDocument<T> | null>;
+	prev(options: RequestInfo<ReactiveDocument<T>>): Promise<ReactiveDocument<T> | null>;
 	/**
 	* Fetches the first link for this document, returning a promise that resolves
 	* with the new document when the request completes, or null if there is no
@@ -119,7 +103,7 @@ export declare class ReactiveDocument<T> {
 	* @param {Object} options
 	* @return {Promise<Document | null>}
 	*/
-	first(options: RequestInfo<ReactiveDocument<T>, T>): Promise<ReactiveDocument<T> | null>;
+	first(options: RequestInfo<ReactiveDocument<T>>): Promise<ReactiveDocument<T> | null>;
 	/**
 	* Fetches the last link for this document, returning a promise that resolves
 	* with the new document when the request completes, or null if there is no
@@ -129,7 +113,7 @@ export declare class ReactiveDocument<T> {
 	* @param {Object} options
 	* @return {Promise<Document | null>}
 	*/
-	last(options: RequestInfo<ReactiveDocument<T>, T>): Promise<ReactiveDocument<T> | null>;
+	last(options: RequestInfo<ReactiveDocument<T>>): Promise<ReactiveDocument<T> | null>;
 	/**
 	* Implemented for `JSON.stringify` support.
 	*

package/declarations/reactive/-private/fields/get-field-key.d.ts

@@ -0,0 +1,8 @@
+import type { CacheableFieldSchema, FieldSchema, HashField, IdentityField } from "../../../types/schema/fields.js";
+type InvalidKind = "alias" | "derived" | "@local";
+export declare function isInvalidKind(kind: string): kind is InvalidKind;
+export declare function isNonIdentityCacheableField(field: FieldSchema | IdentityField | HashField): field is Exclude<CacheableFieldSchema, IdentityField>;
+export declare function getFieldCacheKeyStrict(field: CacheableFieldSchema): string;
+export declare function getFieldCacheKey(field: FieldSchema | IdentityField | HashField): string | null;
+export declare function assertIsCacheField(field: FieldSchema | IdentityField): asserts field is CacheableFieldSchema;
+export {};

package/declarations/reactive/-private/fields/managed-array.d.ts

@@ -1,22 +1,18 @@
-import type { Store } from "../../../index.js";
 import type { WarpDriveSignal } from "../../../store/-private.js";
 import { ARRAY_SIGNAL } from "../../../store/-private.js";
-import type { Cache } from "../../../types/cache.js";
-import type { StableRecordIdentifier } from "../../../types/identifier.js";
+import type { ResourceKey } from "../../../types/identifier.js";
 import type { ArrayField, SchemaArrayField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
 import { ReactiveResource } from "../record.js";
-import type { SchemaService } from "../schema.js";
-import { Editable, Legacy, SOURCE } from "../symbols.js";
+import { Context, SOURCE } from "../symbols.js";
 export interface ManagedArray extends Omit<Array<unknown>, "[]"> {
 	[SOURCE]: unknown[];
-	identifier: StableRecordIdentifier;
-	path: string[];
+	identifier: ResourceKey;
+	path: string | string[];
 	owner: ReactiveResource;
 	[ARRAY_SIGNAL]: WarpDriveSignal;
-	[Editable]: boolean;
-	[Legacy]: boolean;
+	[Context]: KindContext<SchemaArrayField | ArrayField>;
 }
-// eslint-disable-next-line @typescript-eslint/no-extraneous-class
 export declare class ManagedArray {
-	constructor(store: Store, schema: SchemaService, cache: Cache, field: ArrayField | SchemaArrayField, data: unknown[], identifier: StableRecordIdentifier, path: string[], owner: ReactiveResource, isSchemaArray: boolean, editable: boolean, legacy: boolean);
+	constructor(context: KindContext<SchemaArrayField | ArrayField>, owner: ReactiveResource, data: unknown[]);
 }

package/declarations/reactive/-private/fields/managed-object.d.ts

@@ -1,21 +1,17 @@
 import { OBJECT_SIGNAL, type WarpDriveSignal } from "../../../store/-private.js";
-import type { Cache } from "../../../types/cache.js";
-import type { StableRecordIdentifier } from "../../../types/identifier.js";
 import type { ObjectField, SchemaObjectField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
 import type { ReactiveResource } from "../record.js";
-import type { SchemaService } from "../schema.js";
-import { Editable, EmbeddedPath, Legacy, Parent, SOURCE } from "../symbols.js";
+import { Context, SOURCE } from "../symbols.js";
 export declare function notifyObject(obj: ManagedObject): void;
-// const ignoredGlobalFields = new Set<string>(['setInterval', 'nodeType', 'nodeName', 'length', 'document', STRUCTURED]);
 export interface ManagedObject {
 	[SOURCE]: object;
-	[Parent]: StableRecordIdentifier;
-	[EmbeddedPath]: string[];
+	[Context]: KindContext<ObjectField>;
 	[OBJECT_SIGNAL]: WarpDriveSignal;
-	[Editable]: boolean;
-	[Legacy]: boolean;
 }
-// eslint-disable-next-line @typescript-eslint/no-extraneous-class
 export declare class ManagedObject {
-	constructor(schema: SchemaService, cache: Cache, field: ObjectField | SchemaObjectField, data: object, identifier: StableRecordIdentifier, path: string[], owner: ReactiveResource, editable: boolean, legacy: boolean);
+	constructor(context: KindContext<ObjectField>);
 }
+export declare const ManagedObjectMap: Map<ReactiveResource, Map<string, ManagedObject | ReactiveResource>>;
+export declare function peekManagedObject(record: ReactiveResource, field: ObjectField): ManagedObject | undefined;
+export declare function peekManagedObject(record: ReactiveResource, field: SchemaObjectField): ReactiveResource | undefined;

package/declarations/reactive/-private/fields/many-array-manager.d.ts

@@ -1,7 +1,7 @@
 import type { Store } from "../../../index.js";
 import type { RelatedCollection as ManyArray } from "../../../store/-private.js";
 import type { LocalRelationshipOperation } from "../../../types/graph.js";
-import type { StableRecordIdentifier } from "../../../types/identifier.js";
+import type { ResourceKey } from "../../../types/identifier.js";
 import type { ReactiveResource } from "../record.js";
 export interface FindHasManyOptions {
 	reload?: boolean;
@@ -10,7 +10,7 @@ export interface FindHasManyOptions {
 export declare class ManyArrayManager {
 	record: ReactiveResource;
 	store: Store;
-	identifier: StableRecordIdentifier;
+	identifier: ResourceKey;
 	editable: boolean;
 	constructor(record: ReactiveResource, editable: boolean);
 	_syncArray(array: ManyArray): void;

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

@@ -1,5 +1,5 @@
 import type { Store } from "../../index.js";
-import type { StableRecordIdentifier } from "../../types.js";
+import type { ResourceKey } from "../../types.js";
 import { ReactiveResource } from "./record.js";
-export declare function instantiateRecord(store: Store, identifier: StableRecordIdentifier, createArgs?: Record<string, unknown>): ReactiveResource;
+export declare function instantiateRecord(store: Store, identifier: ResourceKey, createArgs?: Record<string, unknown>): ReactiveResource;
 export declare function teardownRecord(record: unknown): void;

package/declarations/reactive/-private/kind/alias-field.d.ts

@@ -0,0 +1,4 @@
+import type { LegacyAliasField, ObjectAliasField, PolarisAliasField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getAliasField(context: KindContext<LegacyAliasField | ObjectAliasField | PolarisAliasField>): unknown;
+export declare function setAliasField(context: KindContext<LegacyAliasField | ObjectAliasField | PolarisAliasField>): boolean;

package/declarations/reactive/-private/kind/array-field.d.ts

@@ -0,0 +1,4 @@
+import type { ArrayField, SchemaArrayField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getArrayField(context: KindContext<ArrayField | SchemaArrayField>): unknown;
+export declare function setArrayField(context: KindContext<ArrayField>): boolean;

package/declarations/reactive/-private/kind/attribute-field.d.ts

@@ -0,0 +1,4 @@
+import type { LegacyAttributeField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getAttributeField(context: KindContext<LegacyAttributeField>): unknown;
+export declare function setAttributeField(context: KindContext<LegacyAttributeField>): boolean;

package/declarations/reactive/-private/kind/belongs-to-field.d.ts

@@ -0,0 +1,4 @@
+import type { LegacyBelongsToField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getBelongsToField(context: KindContext<LegacyBelongsToField>): unknown;
+export declare function setBelongsToField(context: KindContext<LegacyBelongsToField>): boolean;

package/declarations/reactive/-private/kind/collection-field.d.ts

@@ -0,0 +1,4 @@
+import type { CollectionField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getCollectionField(context: KindContext<CollectionField>): unknown;
+export declare function setCollectionField(context: KindContext<CollectionField>): boolean;

package/declarations/reactive/-private/kind/derived-field.d.ts

@@ -0,0 +1,4 @@
+import type { DerivedField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getDerivedField(context: KindContext<DerivedField>): unknown;
+export declare function setDerivedField(context: KindContext<DerivedField>): boolean;

package/declarations/reactive/-private/kind/generic-field.d.ts

@@ -0,0 +1,4 @@
+import type { GenericField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getGenericField(context: KindContext<GenericField>): unknown;
+export declare function setGenericField(context: KindContext<GenericField>): boolean;

package/declarations/reactive/-private/kind/has-many-field.d.ts

@@ -0,0 +1,4 @@
+import type { LegacyHasManyField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getHasManyField(context: KindContext<LegacyHasManyField>): unknown;
+export declare function setHasManyField(context: KindContext<LegacyHasManyField>): boolean;

package/declarations/reactive/-private/kind/hash-field.d.ts

@@ -0,0 +1,4 @@
+import type { HashField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getHashField(context: KindContext<HashField>): unknown;
+export declare function setHashField(context: KindContext<HashField>): boolean;

package/declarations/reactive/-private/kind/identity-field.d.ts

@@ -0,0 +1,4 @@
+import type { IdentityField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getIdentityField(context: KindContext<IdentityField>): unknown;
+export declare function setIdentityField(context: KindContext<IdentityField>): boolean;

package/declarations/reactive/-private/kind/local-field.d.ts

@@ -0,0 +1,4 @@
+import type { LocalField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getLocalField(context: KindContext<LocalField>): unknown;
+export declare function setLocalField(context: KindContext<LocalField>): boolean;

package/declarations/reactive/-private/kind/object-field.d.ts

@@ -0,0 +1,4 @@
+import type { ObjectField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getObjectField(context: KindContext<ObjectField>): unknown;
+export declare function setObjectField(context: KindContext<ObjectField>): boolean;

package/declarations/reactive/-private/kind/resource-field.d.ts

@@ -0,0 +1,4 @@
+import type { ResourceField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getResourceField(context: KindContext<ResourceField>): unknown;
+export declare function setResourceField(context: KindContext<ResourceField>): boolean;

package/declarations/reactive/-private/kind/schema-array-field.d.ts

@@ -0,0 +1,4 @@
+import type { SchemaArrayField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export { getArrayField as getSchemaArrayField } from "./array-field.js";
+export declare function setSchemaArrayField(context: KindContext<SchemaArrayField>): boolean;

package/declarations/reactive/-private/kind/schema-object-field.d.ts

@@ -0,0 +1,4 @@
+import type { SchemaObjectField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getSchemaObjectField(context: KindContext<SchemaObjectField>): unknown;
+export declare function setSchemaObjectField(context: KindContext<SchemaObjectField>): boolean;

package/declarations/reactive/-private/record.d.ts

@@ -1,37 +1,14 @@
-import type { Store } from "../../index.js";
-import type { StableRecordIdentifier } from "../../types/identifier.js";
-import type { SchemaArrayField, SchemaObjectField } from "../../types/schema/fields.js";
-import { RecordStore } from "../../types/symbols.js";
-import { Checkout, Destroy, Editable, EmbeddedField, EmbeddedPath, Identifier, Legacy, Parent } from "./symbols.js";
-export { Editable, Legacy, Checkout } from "./symbols.js";
+import type { ObjectContext, ResourceContext } from "./default-mode.js";
+import { Checkout } from "./symbols.js";
 export interface ReactiveResource {
-	[Symbol.toStringTag]: `ReactiveResource<${string}>`;
-	/** @internal */
-	[RecordStore]: Store;
-	/** @internal */
-	[Identifier]: StableRecordIdentifier;
-	/** @internal */
-	[Parent]: StableRecordIdentifier;
-	/** @internal */
-	[EmbeddedField]: SchemaArrayField | SchemaObjectField | null;
-	/** @internal */
-	[EmbeddedPath]: string[] | null;
-	/** @internal */
-	[Editable]: boolean;
-	/** @internal */
-	[Legacy]: boolean;
-	/** @internal */
-	___notifications: object;
-	/** @internal */
-	[Destroy](): void;
 	/**
 	* Create an editable copy of the record
 	*
 	* ReactiveResource instances are not editable by default. This method creates an editable copy of the record. To use,
-	* import the `Checkout` symbol from `@warp-drive/schema-record` and call it on the record.
+	* import the `Checkout` symbol from `@warp-drive/core/reactive` and call it on the record.
 	*
 	* ```ts
-	* import { Checkout } from '@warp-drive/schema-record';
+	* import { Checkout } from '@warp-drive/core/reactive';
 	*
 	* const record = store.peekRecord('user', '1');
 	* const editableRecord = await record[Checkout]();
@@ -39,13 +16,13 @@ export interface ReactiveResource {
 	*
 	* @returns a promise that resolves to the editable record
 	* @throws if the record is already editable or if the record is embedded
-	*
+	* @private
 	*/
 	[Checkout]<T>(): Promise<T>;
 }
 /**
 * A class that uses a the ResourceSchema for a ResourceType
-* and a ResouceKey to transform data from the cache into a rich, reactive
+* and a ResourceKey to transform data from the cache into a rich, reactive
 * object.
 *
 * This class is not directly instantiable. To use it, you should
@@ -55,10 +32,43 @@ export interface ReactiveResource {
 * @hideconstructor
 * @public
 */
-// eslint-disable-next-line @typescript-eslint/no-extraneous-class
 export declare class ReactiveResource {
-	constructor(store: Store, identifier: StableRecordIdentifier, Mode: {
-		[Editable]: boolean;
-		[Legacy]: boolean;
-	}, isEmbedded?: boolean, embeddedField?: SchemaArrayField | SchemaObjectField | null, embeddedPath?: string[] | null);
+	constructor(context: ResourceContext | ObjectContext);
 }
+export declare function _CHECKOUT(record: ReactiveResource): ReactiveResource;
+/**
+* Checkout an immutable resource for editing.
+*
+* {@link ReactiveResource | ReactiveResources} are not editable by default. This method
+* creates an editable copy of the resource.
+*
+* This returns a promise which resolves with the editable
+* version of the resource.
+*
+* ```ts
+* import { checkout } from '@warp-drive/core/reactive';
+*
+* const immutable = store.peekRecord('user', '1');
+* const editable = await checkout(immutable);
+* ```
+*
+* Edits to editable resources will be automatically committed if a new
+* payload from the cache matches their existing value.
+*
+* @public
+*
+* @returns a promise that resolves to the editable resource
+* @throws if the resource is already editable or if resource is an embedded object
+*/
+export declare function checkout<T>(resource: unknown): Promise<T & ReactiveResource>;
+/**
+* Forcibly commit all local changes on an editable resource to
+* the remote (immutable) version.
+*
+* This API should only be used cautiously. Typically a better
+* approach is for either the API or a Handler to reflect saved
+* changes back to update the cache.
+*
+* @public
+*/
+export declare function commit(record: ReactiveResource): Promise<void>;

package/declarations/reactive/-private/schema.d.ts

@@ -1,9 +1,8 @@
-import type { Store } from "../../store/-private.js";
 import type { SchemaService as SchemaServiceInterface } from "../../types.js";
-import type { StableRecordIdentifier } from "../../types/identifier.js";
+import type { ResourceKey } from "../../types/identifier.js";
 import type { ObjectValue, Value } from "../../types/json/raw.js";
 import type { Derivation, HashFn } from "../../types/schema/concepts.js";
-import { type ArrayField, type DerivedField, type FieldSchema, type GenericField, type HashField, type LegacyAttributeField, type LegacyBelongsToField, type LegacyHasManyField, type LegacyRelationshipField, type ObjectField, type ObjectSchema, type PolarisResourceSchema, type ResourceSchema } from "../../types/schema/fields.js";
+import { type ArrayField, type CacheableFieldSchema, type DerivedField, type FieldSchema, type GenericField, type HashField, type IdentityField, type LegacyAttributeField, type LegacyRelationshipField, type ObjectField, type ObjectSchema, type PolarisResourceSchema, type ResourceSchema, type Trait } from "../../types/schema/fields.js";
 import { Type } from "../../types/symbols.js";
 import type { WithPartial } from "../../types/utils.js";
 import type { ReactiveResource } from "./record.js";
@@ -31,12 +30,10 @@ export interface CAUTION_MEGA_DANGER_ZONE_Extension {
 	* A constructable such as a Function or Class whose prototype
 	* will be iterated with getOwnPropertyNames.
 	*/
-	// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
 	features: Record<string | symbol, unknown> | Function;
 }
 export type ExtensionDef = {
 	kind: "method";
-	// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
 	fn: Function;
 } | {
 	kind: "readonly-value";
@@ -95,11 +92,11 @@ interface FromIdentityDerivation {
 	}, key: string): string | null;
 	(record: ReactiveResource, options: {
 		key: "^";
-	}, key: string): StableRecordIdentifier;
+	}, key: string): ResourceKey;
 	(record: ReactiveResource, options: null, key: string): asserts options;
 	(record: ReactiveResource, options: {
 		key: "id" | "lid" | "type" | "^";
-	} | null, key: string): StableRecordIdentifier | string | null;
+	} | null, key: string): ResourceKey | string | null;
 	[Type]: "@identity";
 }
 /**
@@ -133,13 +130,14 @@ export declare const fromIdentity: FromIdentityDerivation;
 * ```
 *
 * @public
-* @param {SchemaService} schema
 */
 export declare function registerDerivations(schema: SchemaServiceInterface): void;
 interface InternalSchema {
 	original: ResourceSchema | ObjectSchema;
+	finalized: boolean;
 	traits: Set<string>;
 	fields: Map<string, FieldSchema>;
+	cacheFields: Map<string, Exclude<CacheableFieldSchema, IdentityField>>;
 	attributes: Record<string, LegacyAttributeField>;
 	relationships: Record<string, LegacyRelationshipField>;
 }
@@ -149,20 +147,9 @@ export type Transformation<
 > = {
 	serialize(value: PT, options: Record<string, unknown> | null, record: ReactiveResource): T;
 	hydrate(value: T | undefined, options: Record<string, unknown> | null, record: ReactiveResource): PT;
-	defaultValue?(options: Record<string, unknown> | null, identifier: StableRecordIdentifier): T;
+	defaultValue?(options: Record<string, unknown> | null, identifier: ResourceKey): T;
 	[Type]: string;
 };
-interface KindFns {
-	belongsTo: {
-		get: (store: Store, record: object, resourceKey: StableRecordIdentifier, field: LegacyBelongsToField) => unknown;
-		set: (store: Store, record: object, cacheKey: StableRecordIdentifier, field: LegacyBelongsToField, value: unknown) => void;
-	};
-	hasMany: {
-		get: (store: Store, record: object, resourceKey: StableRecordIdentifier, field: LegacyHasManyField) => unknown;
-		set: (store: Store, record: object, cacheKey: StableRecordIdentifier, field: LegacyHasManyField, value: unknown) => void;
-		notify: (store: Store, record: object, cacheKey: StableRecordIdentifier, field: LegacyHasManyField) => boolean;
-	};
-}
 export interface SchemaService {
 	doesTypeExist(type: string): boolean;
 	attributesDefinitionFor(identifier: {
@@ -175,36 +162,13 @@ export interface SchemaService {
 /**
 * A SchemaService designed to work with dynamically registered schemas.
 *
-* @class SchemaService
 * @public
 */
 export declare class SchemaService implements SchemaServiceInterface {
-	/** @internal */
-	_schemas: Map<string, InternalSchema>;
-	/** @internal */
-	_transforms: Map<string, Transformation>;
-	/** @internal */
-	_hashFns: Map<string, HashFn>;
-	/** @internal */
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	_derivations: Map<string, Derivation<any, any, any>>;
-	/** @internal */
-	_traits: Set<string>;
-	/** @internal */
-	_modes: Map<string, KindFns>;
-	/** @internal */
-	_extensions: {
-		object: Map<string, ProcessedExtension>;
-		array: Map<string, ProcessedExtension>;
-	};
-	_cachedFieldExtensionsByField: {
-		object: Map<object, ProcessedExtension["features"] | null>;
-		array: Map<object, ProcessedExtension["features"] | null>;
-	};
 	constructor();
 	resourceTypes(): Readonly<string[]>;
 	hasTrait(type: string): boolean;
-	resourceHasTrait(resource: StableRecordIdentifier | {
+	resourceHasTrait(resource: ResourceKey | {
 		type: string;
 	}, trait: string): boolean;
 	transformation(field: GenericField | ObjectField | ArrayField | {
@@ -216,11 +180,40 @@ export declare class SchemaService implements SchemaServiceInterface {
 	hashFn(field: HashField | {
 		type: string;
 	}): HashFn;
-	resource(resource: StableRecordIdentifier | {
+	resource(resource: ResourceKey | {
 		type: string;
 	}): ResourceSchema | ObjectSchema;
 	registerResources(schemas: Array<ResourceSchema | ObjectSchema>): void;
 	registerResource(schema: ResourceSchema | ObjectSchema): void;
+	/**
+	* Registers a {@link Trait} for use by resource schemas.
+	*
+	* Traits are re-usable collections of fields that can be composed to
+	* build up a resource schema. Often they represent polymorphic behaviors
+	* a resource should exhibit.
+	*
+	* When we finalize a resource, we walk its traits and apply their fields
+	* to the resource's fields. All specified traits must be registered by
+	* this time or an error will be thrown.
+	*
+	* Traits are applied left-to-right, with traits of traits being applied in the same
+	* way. Thus for the most part, application of traits is a post-order graph traversal
+	* problem.
+	*
+	* A trait is only ever processed once. If multiple traits (A, B, C) have the same
+	* trait (D) as a dependency, D will be included only once when first encountered by
+	* A.
+	*
+	* If a cycle exists such that trait A has trait B which has Trait A, trait A will
+	* be applied *after* trait B in production. In development a cycle error will be thrown.
+	*
+	* Fields are finalized on a "last wins principle". Thus traits appearing higher in
+	* the tree and further to the right of a traits array take precedence, with the
+	* resource's fields always being applied last and winning out.
+	*
+	* @public
+	*/
+	registerTrait(trait: Trait): void;
 	registerTransformation<
 		T extends Value = string,
 		PT = unknown
@@ -231,39 +224,28 @@ export declare class SchemaService implements SchemaServiceInterface {
 		FM extends ObjectValue | null
 	>(derivation: Derivation<R, T, FM>): void;
 	CAUTION_MEGA_DANGER_ZONE_registerExtension(extension: CAUTION_MEGA_DANGER_ZONE_Extension): void;
-	CAUTION_MEGA_DANGER_ZONE_resourceExtensions(resource: StableRecordIdentifier | {
+	CAUTION_MEGA_DANGER_ZONE_resourceExtensions(resource: ResourceKey | {
 		type: string;
 	}): null | ProcessedExtension["features"];
-	CAUTION_MEGA_DANGER_ZONE_objectExtensions(field: ExtensibleField): 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"];
+	CAUTION_MEGA_DANGER_ZONE_hasExtension(ext: {
+		kind: "object" | "array";
+		name: string;
+	}): boolean;
 	/**
-	* This is an internal method used to register behaviors for legacy mode.
-	* It is not intended for public use.
-	*
-	* We do think a generalized `kind` registration system would be useful,
-	* but we have not yet designed it.
-	*
-	* See https://github.com/emberjs/data/issues/9534
-	*
-	* @internal
-	*/
-	_registerMode(mode: string, kinds: KindFns): void;
-	/**
-	* This is an internal method used to enable legacy behaviors for legacy mode.
-	* It is not intended for public use.
-	*
-	* We do think a generalized `kind` registration system would be useful,
-	* but we have not yet designed it.
+	* Registers a {@link HashFn} for use with a {@link HashField} for
+	* either {@link ObjectSchema} identity or polymorphic type calculation.
 	*
-	* See https://github.com/emberjs/data/issues/9534
-	*
-	* @internal
+	* @public
 	*/
-	_kind<T extends keyof KindFns>(mode: string, kind: T): KindFns[T];
 	registerHashFn<T extends object>(hashFn: HashFn<T>): void;
 	fields({ type }: {
 		type: string;
 	}): InternalSchema["fields"];
+	cacheFields({ type }: {
+		type: string;
+	}): InternalSchema["cacheFields"];
 	hasResource(resource: {
 		type: string;
 	}): boolean;