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

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

@@ -1,146 +0,0 @@
-import type { Store } from "../../store/-private/store-service.js";
-import type { StableDocumentIdentifier } 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.
-*
-* It is not directly instantiated by the user, and its properties should not
-* be directly modified. Whether individual properties are mutable or not is
-* determined by the record instance itself.
-*
-* @public
-* @hideconstructor
-*/
-export declare class ReactiveDocument<T> {
-	#private;
-	/**
-	* The links object for this document, if any
-	*
-	* e.g.
-	*
-	* ```
-	* {
-	*   self: '/articles?page[number]=3',
-	* }
-	* ```
-	*
-	* @property links
-	* @type {Object|undefined} - a links object
-	* @public
-	*/
-	readonly links?: PaginationLinks;
-	/**
-	* The primary data for this document, if any.
-	*
-	* If this document has no primary data (e.g. because it is an error document)
-	* this property will be `undefined`.
-	*
-	* 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
-	*
-	* @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: {
-		document: ResourceDocument;
-		request: ImmutableRequestInfo;
-	} | null);
-	/**
-	* Fetches the related link for this document, returning a promise that resolves
-	* with the document when the request completes. If no related link is present,
-	* will fallback to the self link if present
-	*
-	* @public
-	* @param {Object} options
-	* @return {Promise<Document>}
-	*/
-	fetch(options?: RequestInfo<ReactiveDocument<T>, 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
-	* next link.
-	*
-	* @public
-	* @param {Object} options
-	* @return {Promise<Document | null>}
-	*/
-	next(options?: RequestInfo<ReactiveDocument<T>, 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
-	* prev link.
-	*
-	* @public
-	* @param {Object} options
-	* @return {Promise<Document | null>}
-	*/
-	prev(options: RequestInfo<ReactiveDocument<T>, 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
-	* first link.
-	*
-	* @public
-	* @param {Object} options
-	* @return {Promise<Document | null>}
-	*/
-	first(options: RequestInfo<ReactiveDocument<T>, 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
-	* last link.
-	*
-	* @public
-	* @param {Object} options
-	* @return {Promise<Document | null>}
-	*/
-	last(options: RequestInfo<ReactiveDocument<T>, T>): Promise<ReactiveDocument<T> | null>;
-	/**
-	* Implemented for `JSON.stringify` support.
-	*
-	* Returns the JSON representation of the document wrapper.
-	*
-	* This is a shallow serialization, it does not deeply serialize
-	* the document's contents, leaving that to the individual record
-	* instances to determine how to do, if at all.
-	*
-	* @public
-	* @return
-	*/
-	toJSON(): object;
-}

package/declarations/reactive/-private/fields/compute.d.ts

@@ -1,43 +0,0 @@
-import type { Store, StoreRequestInput } from "../../../index.js";
-import type { Future } from "../../../request.js";
-import { RelatedCollection as ManyArray } from "../../../store/-private.js";
-import type { Cache } from "../../../types/cache.js";
-import type { StableRecordIdentifier } from "../../../types/identifier.js";
-import type { ArrayField, DerivedField, FieldSchema, GenericField, LegacyHasManyField, LocalField, ObjectField, SchemaArrayField, SchemaObjectField } from "../../../types/schema/fields.js";
-import type { Links } from "../../../types/spec/json-api-raw.js";
-import { RecordStore } from "../../../types/symbols.js";
-import { ReactiveResource } from "../record.js";
-import type { SchemaService } from "../schema.js";
-import { Parent } from "../symbols.js";
-import { ManagedArray } from "./managed-array.js";
-import { ManagedObject } from "./managed-object.js";
-export declare const ManagedArrayMap: Map<ReactiveResource, Map<string, ManagedArray | ManyArray>>;
-export declare const ManagedObjectMap: Map<ReactiveResource, Map<string, ManagedObject | ReactiveResource>>;
-export declare function computeLocal(record: typeof Proxy<ReactiveResource>, field: LocalField, prop: string): unknown;
-export declare function peekManagedArray(record: ReactiveResource, field: FieldSchema): ManyArray | ManagedArray | undefined;
-export declare function peekManagedObject(record: ReactiveResource, field: ObjectField): ManagedObject | undefined;
-export declare function peekManagedObject(record: ReactiveResource, field: SchemaObjectField): ReactiveResource | undefined;
-export declare function computeField(schema: SchemaService, cache: Cache, record: ReactiveResource, identifier: StableRecordIdentifier, field: GenericField, prop: string | string[], editable: boolean): unknown;
-export declare function computeArray(store: Store, schema: SchemaService, cache: Cache, record: ReactiveResource, identifier: StableRecordIdentifier, field: ArrayField | SchemaArrayField, path: string[], editable: boolean, legacy: boolean): ManagedArray | null;
-export declare function computeObject(schema: SchemaService, cache: Cache, record: ReactiveResource, identifier: StableRecordIdentifier, field: ObjectField, path: string[], editable: boolean, legacy: boolean): ManagedObject | null;
-export declare function computeSchemaObject(store: Store, cache: Cache, record: ReactiveResource, identifier: StableRecordIdentifier, field: SchemaObjectField, path: string[], legacy: boolean, editable: boolean): ReactiveResource | null;
-export declare function computeAttribute(cache: Cache, identifier: StableRecordIdentifier, prop: string, editable: boolean): unknown;
-export declare function computeDerivation(schema: SchemaService, record: ReactiveResource, identifier: StableRecordIdentifier, field: DerivedField, prop: string): unknown;
-interface ResourceRelationship<T extends ReactiveResource = ReactiveResource> {
-	lid: string;
-	[Parent]: ReactiveResource;
-	[RecordStore]: Store;
-	name: string;
-	data: T | null;
-	links: Links;
-	meta: Record<string, unknown>;
-}
-// TODO probably this should just be a Document
-// but its separate until we work out the lid situation
-declare class ResourceRelationship<T extends ReactiveResource = ReactiveResource> {
-	constructor(store: Store, cache: Cache, parent: ReactiveResource, identifier: StableRecordIdentifier, field: FieldSchema, name: string, editable: boolean);
-	fetch(options?: StoreRequestInput<T, T>): Future<T>;
-}
-export declare function computeResource<T extends ReactiveResource>(store: Store, cache: Cache, parent: ReactiveResource, identifier: StableRecordIdentifier, field: FieldSchema, prop: string, editable: boolean): ResourceRelationship<T>;
-export declare function computeHasMany(store: Store, schema: SchemaService, cache: Cache, record: ReactiveResource, identifier: StableRecordIdentifier, field: LegacyHasManyField, path: string[], editable: boolean, legacy: boolean): ManyArray | null;
-export {};

package/declarations/reactive/-private/fields/extension.d.ts

@@ -1,8 +0,0 @@
-import type { SignalStore, WarpDriveSignal } from "../../../store/-private/new-core-tmp/reactivity/internal.js";
-import type { ExtensionDef } from "../schema.js";
-export type ProxiedMethod = (...args: unknown[]) => unknown;
-export declare function expectNever(value: never): void;
-export declare function isExtensionProp(extensions: Map<string | symbol, ExtensionDef> | null, prop: string | number | symbol): prop is string | symbol;
-export declare function performObjectExtensionGet(receiver: object, extensions: Map<string | symbol, ExtensionDef>, signals: SignalStore, prop: string | symbol): unknown;
-export declare function performExtensionSet(receiver: object, extensions: Map<string | symbol, ExtensionDef>, signals: SignalStore, prop: string | symbol, value: unknown): boolean;
-export declare function performArrayExtensionGet(receiver: object, extensions: Map<string | symbol, ExtensionDef>, signals: SignalStore, prop: string | symbol, _SIGNAL: WarpDriveSignal, boundFns: Map<string | symbol | number, ProxiedMethod>, transaction: (v: boolean) => void): unknown;

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

@@ -1,22 +0,0 @@
-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 { ArrayField, SchemaArrayField } from "../../../types/schema/fields.js";
-import { ReactiveResource } from "../record.js";
-import type { SchemaService } from "../schema.js";
-import { Editable, Legacy, SOURCE } from "../symbols.js";
-export interface ManagedArray extends Omit<Array<unknown>, "[]"> {
-	[SOURCE]: unknown[];
-	identifier: StableRecordIdentifier;
-	path: string[];
-	owner: ReactiveResource;
-	[ARRAY_SIGNAL]: WarpDriveSignal;
-	[Editable]: boolean;
-	[Legacy]: boolean;
-}
-// 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);
-}

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

@@ -1,21 +0,0 @@
-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 { ReactiveResource } from "../record.js";
-import type { SchemaService } from "../schema.js";
-import { Editable, EmbeddedPath, Legacy, Parent, 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[];
-	[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);
-}

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

@@ -1,19 +0,0 @@
-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 { ReactiveResource } from "../record.js";
-export interface FindHasManyOptions {
-	reload?: boolean;
-	backgroundReload?: boolean;
-}
-export declare class ManyArrayManager {
-	record: ReactiveResource;
-	store: Store;
-	identifier: StableRecordIdentifier;
-	editable: boolean;
-	constructor(record: ReactiveResource, editable: boolean);
-	_syncArray(array: ManyArray): void;
-	reloadHasMany<T>(key: string, options?: FindHasManyOptions): Promise<ManyArray<T>>;
-	mutate(mutation: LocalRelationshipOperation): void;
-}

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

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

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

@@ -1,64 +0,0 @@
-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";
-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.
-	*
-	* ```ts
-	* import { Checkout } from '@warp-drive/schema-record';
-	*
-	* const record = store.peekRecord('user', '1');
-	* const editableRecord = await record[Checkout]();
-	* ```
-	*
-	* @returns a promise that resolves to the editable record
-	* @throws if the record is already editable or if the record is embedded
-	*
-	*/
-	[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
-* object.
-*
-* This class is not directly instantiable. To use it, you should
-* configure the store's `instantiateRecord` and `teardownRecord` hooks
-* with the matching hooks provided by this package.
-*
-* @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);
-}

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

@@ -1,271 +0,0 @@
-import type { Store } from "../../store/-private.js";
-import type { SchemaService as SchemaServiceInterface } from "../../types.js";
-import type { StableRecordIdentifier } 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 } from "../../types/symbols.js";
-import type { WithPartial } from "../../types/utils.js";
-import type { ReactiveResource } from "./record.js";
-/**
-* Extensions allow providing non-schema driven behaviors to
-* reactive resources and arrays.
-*/
-export interface CAUTION_MEGA_DANGER_ZONE_Extension {
-	/**
-	* Whether this extension extends the behaviors of objects
-	* or of arrays.
-	*/
-	kind: "object" | "array";
-	/**
-	* The name of the extension, to be used when specifying
-	* either `objectExtensions` or `arrayExtensions`
-	*/
-	name: string;
-	/**
-	* An object with iterable keys whose values are the getters
-	* or methods to expose on the object or array.
-	*
-	* or
-	*
-	* 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";
-	value: unknown;
-} | {
-	kind: "mutable-value";
-	value: unknown;
-} | {
-	kind: "readonly-field";
-	get: () => unknown;
-} | {
-	kind: "mutable-field";
-	get: () => unknown;
-	set: (value: unknown) => void;
-} | {
-	kind: "writeonly-field";
-	set: (value: unknown) => void;
-};
-export interface ProcessedExtension {
-	kind: "object" | "array";
-	name: string;
-	features: Map<string | symbol, ExtensionDef>;
-}
-export interface ExtensibleField {
-	kind: "schema-object" | "schema-array" | "array" | "object" | "hasMany";
-	options?: {
-		objectExtensions?: string[];
-		arrayExtensions?: string[];
-	};
-}
-/**
-* Utility for constructing a ResourceSchema with the recommended
-* fields for the PolarisMode experience.
-*
-* Using this requires registering the PolarisMode derivations
-*
-* ```ts
-* import { registerDerivations } from '@warp-drive/schema-record';
-*
-* registerDerivations(schema);
-* ```
-*
-* @public
-* @param schema
-* @return {PolarisResourceSchema}
-*/
-export declare function withDefaults(schema: WithPartial<PolarisResourceSchema, "identity">): ResourceSchema;
-interface FromIdentityDerivation {
-	(record: ReactiveResource, options: {
-		key: "lid";
-	} | {
-		key: "type";
-	}, key: string): string;
-	(record: ReactiveResource, options: {
-		key: "id";
-	}, key: string): string | null;
-	(record: ReactiveResource, options: {
-		key: "^";
-	}, key: string): StableRecordIdentifier;
-	(record: ReactiveResource, options: null, key: string): asserts options;
-	(record: ReactiveResource, options: {
-		key: "id" | "lid" | "type" | "^";
-	} | null, key: string): StableRecordIdentifier | string | null;
-	[Type]: "@identity";
-}
-/**
-* A derivation that computes its value from the
-* record's identity.
-*
-* It can be used via a derived field definition like:
-*
-* ```ts
-* {
-*   kind: 'derived',
-*   name: 'id',
-*   type: '@identity',
-*   options: { key: 'id' }
-* }
-* ```
-*
-* Valid keys are `'id'`, `'lid'`, `'type'`, and `'^'`.
-*
-* `^` returns the entire identifier object.
-*
-* @public
-*/
-export declare const fromIdentity: FromIdentityDerivation;
-/**
-* Registers the default derivations for records that want
-* to use the PolarisMode defaults provided by
-*
-* ```ts
-* import { withDefaults } from '@warp-drive/schema-record';
-* ```
-*
-* @public
-* @param {SchemaService} schema
-*/
-export declare function registerDerivations(schema: SchemaServiceInterface): void;
-interface InternalSchema {
-	original: ResourceSchema | ObjectSchema;
-	traits: Set<string>;
-	fields: Map<string, FieldSchema>;
-	attributes: Record<string, LegacyAttributeField>;
-	relationships: Record<string, LegacyRelationshipField>;
-}
-export type Transformation<
-	T extends Value = Value,
-	PT = unknown
-> = {
-	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;
-	[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: {
-		type: string;
-	}): InternalSchema["attributes"];
-	relationshipsDefinitionFor(identifier: {
-		type: string;
-	}): InternalSchema["relationships"];
-}
-/**
-* 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 | {
-		type: string;
-	}, trait: string): boolean;
-	transformation(field: GenericField | ObjectField | ArrayField | {
-		type: string;
-	}): Transformation;
-	derivation(field: DerivedField | {
-		type: string;
-	}): Derivation;
-	hashFn(field: HashField | {
-		type: string;
-	}): HashFn;
-	resource(resource: StableRecordIdentifier | {
-		type: string;
-	}): ResourceSchema | ObjectSchema;
-	registerResources(schemas: Array<ResourceSchema | ObjectSchema>): void;
-	registerResource(schema: ResourceSchema | ObjectSchema): void;
-	registerTransformation<
-		T extends Value = string,
-		PT = unknown
-	>(transformation: Transformation<T, PT>): void;
-	registerDerivation<
-		R,
-		T,
-		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 | {
-		type: string;
-	}): null | ProcessedExtension["features"];
-	CAUTION_MEGA_DANGER_ZONE_objectExtensions(field: ExtensibleField): null | ProcessedExtension["features"];
-	CAUTION_MEGA_DANGER_ZONE_arrayExtensions(field: ExtensibleField): null | ProcessedExtension["features"];
-	/**
-	* 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.
-	*
-	* See https://github.com/emberjs/data/issues/9534
-	*
-	* @internal
-	*/
-	_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"];
-	hasResource(resource: {
-		type: string;
-	}): boolean;
-}
-export {};

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

@@ -1,36 +0,0 @@
-// Great, got your attention with that warning didn't we?
-// Good. Here's the deal: typescript treats symbols as unique types.
-// If by accident a module creating a symbol is processed more than
-// once, the symbol will be different in each processing. This will
-// cause a type error.
-// It could also cause a runtime error if the symbol is used innapropriately.
-// However, this case is extremely hard to hit and would require other things
-// to go wrong first.
-//
-// So, why do the warning? And why do we lie about the types of the symbols?
-//
-// Because we intentionally create multiple copies of them within the types
-// at build time. This is because we rollup our d.ts files in order to give
-// our consumers a better experience.
-//
-// However, no tool today supports rolling up d.ts files with multiple entry
-// points correctly. The tool we use currently (vite-plugin-dts) uses @microsoft/api-extractor
-// which creates a fully unique stand-alone types file per-entry-point. Thus
-// every entry point that uses one of these symbols somewhere will have accidentally
-// created a new symbol type.
-//
-// This cast allows us to rollup these types using this tool while not encountering
-// the unique symbol type issue.
-//
-// Note that none of these symbols are part of the public API, these are used for
-// debugging DX and as a safe way to provide an intimate contract on public objects.
-export declare const SOURCE: "___(unique) Symbol(SOURCE)";
-export declare const MUTATE: "___(unique) Symbol(MUTATE)";
-export declare const Destroy: "___(unique) Symbol(Destroy)";
-export declare const Identifier: "___(unique) Symbol(Identifier)";
-export declare const Editable: "___(unique) Symbol(Editable)";
-export declare const Parent: "___(unique) Symbol(Parent)";
-export declare const Checkout: "___(unique) Symbol(Checkout)";
-export declare const Legacy: "___(unique) Symbol(Legacy)";
-export declare const EmbeddedPath: "___(unique) Symbol(EmbeddedPath)";
-export declare const EmbeddedField: "___(unique) Symbol(EmbeddedField)";

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

@@ -1 +0,0 @@
-export { Editable, Legacy } from "./-private/symbols.js";

package/declarations/reactive.d.ts

@@ -1,4 +0,0 @@
-export { instantiateRecord, teardownRecord } from "./reactive/-private/hooks.js";
-export { type CAUTION_MEGA_DANGER_ZONE_Extension, type ProcessedExtension, type ExtensionDef, type Transformation, SchemaService, withDefaults, fromIdentity, registerDerivations } from "./reactive/-private/schema.js";
-export { type ReactiveResource } from "./reactive/-private/record.js";
-export { Checkout } from "./reactive/-private/symbols.js";