@warp-drive/core 5.6.0-alpha.14 → 5.6.0-alpha.17

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

@@ -1,147 +1,146 @@
-import type { Store } from '../../store/-private/store-service.ts';
-import type { StableDocumentIdentifier } from '../../types/identifier.ts';
-import type { ImmutableRequestInfo, RequestInfo } from '../../types/request.ts';
-import type { ResourceDocument } from '../../types/spec/document.ts';
-import type { Meta, PaginationLinks } from '../../types/spec/json-api-raw.ts';
+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
- */
+* 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;
+	#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;
 }
-//# sourceMappingURL=document.d.ts.map

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

@@ -1,40 +1,43 @@
-import type { Store, StoreRequestInput } from '../../../index.ts';
-import type { Future } from '../../../request.ts';
-import { RelatedCollection as ManyArray } from '../../../store/-private.ts';
-import type { Cache } from '../../../types/cache.ts';
-import type { StableRecordIdentifier } from '../../../types/identifier.ts';
-import type { ArrayField, DerivedField, FieldSchema, GenericField, LegacyHasManyField, LocalField, ObjectField, SchemaArrayField, SchemaObjectField } from '../../../types/schema/fields.ts';
-import type { Links } from '../../../types/spec/json-api-raw.ts';
-import { RecordStore } from '../../../types/symbols.ts';
-import { ReactiveResource } from '../record.ts';
-import type { SchemaService } from '../schema.ts';
-import { Parent } from '../symbols.ts';
-import { ManagedArray } from './managed-array.ts';
-import { ManagedObject } from './managed-object.ts';
-export declare const ManagedArrayMap: Map<ReactiveResource, Map<string, ManagedArray | ManyArray<unknown>>>;
-export declare const ManagedObjectMap: Map<ReactiveResource, Map<string, ReactiveResource | ManagedObject>>;
+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): ReactiveResource | ManagedObject | null;
-export declare function computeSchemaObject(store: Store, cache: Cache, record: ReactiveResource, identifier: StableRecordIdentifier, field: SchemaObjectField, path: string[], legacy: boolean, editable: boolean): ReactiveResource | ManagedObject | 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> {
-    lid: string;
-    [Parent]: ReactiveResource;
-    [RecordStore]: Store;
-    name: string;
-    data: T | null;
-    links: Links;
-    meta: Record<string, unknown>;
-    constructor(store: Store, cache: Cache, parent: ReactiveResource, identifier: StableRecordIdentifier, field: FieldSchema, name: string, editable: boolean);
-    fetch(options?: StoreRequestInput<T, T>): Future<T>;
+	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<unknown> | null;
+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 {};
-//# sourceMappingURL=compute.d.ts.map

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

@@ -0,0 +1,8 @@
+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,23 +1,22 @@
-import type { Store } from '../../../index.ts';
-import type { WarpDriveSignal } from '../../../store/-private.ts';
-import { ARRAY_SIGNAL } from '../../../store/-private.ts';
-import type { Cache } from '../../../types/cache.ts';
-import type { StableRecordIdentifier } from '../../../types/identifier.ts';
-import type { ArrayField, SchemaArrayField } from '../../../types/schema/fields.ts';
-import { ReactiveResource } from '../record.ts';
-import type { SchemaService } from '../schema.ts';
-import { Editable, Legacy, MUTATE, SOURCE } from '../symbols.ts';
-export interface ManagedArray extends Omit<Array<unknown>, '[]'> {
-    [MUTATE]?(target: unknown[], receiver: typeof Proxy<unknown[]>, prop: string, args: unknown[], _SIGNAL: WarpDriveSignal): unknown;
+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 {
-    [SOURCE]: unknown[];
-    identifier: StableRecordIdentifier;
-    path: string[];
-    owner: ReactiveResource;
-    [ARRAY_SIGNAL]: WarpDriveSignal;
-    [Editable]: boolean;
-    [Legacy]: boolean;
-    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(store: Store, schema: SchemaService, cache: Cache, field: ArrayField | SchemaArrayField, data: unknown[], identifier: StableRecordIdentifier, path: string[], owner: ReactiveResource, isSchemaArray: boolean, editable: boolean, legacy: boolean);
 }
-//# sourceMappingURL=managed-array.d.ts.map

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

@@ -1,21 +1,21 @@
-import { OBJECT_SIGNAL, type WarpDriveSignal } from '../../../store/-private.ts';
-import type { Cache } from '../../../types/cache.ts';
-import type { StableRecordIdentifier } from '../../../types/identifier.ts';
-import type { ObjectField, SchemaObjectField } from '../../../types/schema/fields.ts';
-import type { ReactiveResource } from '../record.ts';
-import type { SchemaService } from '../schema.ts';
-import { Editable, EmbeddedPath, Legacy, MUTATE, Parent, SOURCE } from '../symbols.ts';
+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 {
-    [MUTATE]?(target: unknown[], receiver: typeof Proxy<unknown[]>, prop: string, args: unknown[], _SIGNAL: WarpDriveSignal): unknown;
+	[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 {
-    [SOURCE]: object;
-    [Parent]: StableRecordIdentifier;
-    [EmbeddedPath]: string[];
-    [OBJECT_SIGNAL]: WarpDriveSignal;
-    [Editable]: boolean;
-    [Legacy]: boolean;
-    constructor(schema: SchemaService, cache: Cache, field: ObjectField | SchemaObjectField, data: object, identifier: StableRecordIdentifier, path: string[], owner: ReactiveResource, editable: boolean, legacy: boolean);
+	constructor(schema: SchemaService, cache: Cache, field: ObjectField | SchemaObjectField, data: object, identifier: StableRecordIdentifier, path: string[], owner: ReactiveResource, editable: boolean, legacy: boolean);
 }
-//# sourceMappingURL=managed-object.d.ts.map

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

@@ -1,20 +1,19 @@
-import type { Store } from '../../../index.ts';
-import type { RelatedCollection as ManyArray } from '../../../store/-private.ts';
-import type { LocalRelationshipOperation } from '../../../types/graph.ts';
-import type { StableRecordIdentifier } from '../../../types/identifier.ts';
-import type { ReactiveResource } from '../record.ts';
+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;
+	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;
+	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;
 }
-//# sourceMappingURL=many-array-manager.d.ts.map

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

@@ -1,6 +1,5 @@
-import type { Store } from '../../index.ts';
-import type { StableRecordIdentifier } from '../../types.ts';
-import { ReactiveResource } from './record.ts';
+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;
-//# sourceMappingURL=hooks.d.ts.map

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

@@ -1,61 +1,64 @@
-import type { Store } from '../../index.ts';
-import type { StableRecordIdentifier } from '../../types/identifier.ts';
-import { RecordStore } from '../../types/symbols.ts';
-import { Checkout, Destroy, Editable, EmbeddedPath, EmbeddedType, Identifier, Legacy, Parent } from './symbols.ts';
-export { Editable, Legacy, Checkout } from './symbols';
+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
- */
+* 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 {
-    /** @internal */
-    [RecordStore]: Store;
-    /** @internal */
-    [Identifier]: StableRecordIdentifier;
-    /** @internal */
-    [Parent]: StableRecordIdentifier;
-    /** @internal */
-    [EmbeddedType]: string | null;
-    /** @internal */
-    [EmbeddedPath]: string[] | null;
-    /** @internal */
-    [Editable]: boolean;
-    /** @internal */
-    [Legacy]: boolean;
-    [Symbol.toStringTag]: `ReactiveResource<${string}>`;
-    /** @internal */
-    ___notifications: object;
-    constructor(store: Store, identifier: StableRecordIdentifier, Mode: {
-        [Editable]: boolean;
-        [Legacy]: boolean;
-    }, isEmbedded?: boolean, embeddedType?: string | null, embeddedPath?: string[] | null);
-    /** @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](): Promise<ReactiveResource>;
+	constructor(store: Store, identifier: StableRecordIdentifier, Mode: {
+		[Editable]: boolean;
+		[Legacy]: boolean;
+	}, isEmbedded?: boolean, embeddedField?: SchemaArrayField | SchemaObjectField | null, embeddedPath?: string[] | null);
 }
-//# sourceMappingURL=record.d.ts.map