@warp-drive/legacy 5.6.0-alpha.15 → 5.6.0-alpha.18

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

@@ -1,14 +1,13 @@
-import type { Store } from '@warp-drive/core';
-import type { CompatStore } from '../compat.ts';
+import type { Store } from "@warp-drive/core";
+import type { CompatStore } from "../compat.js";
 /**
- * Utilities - often temporary - for maintaining backwards compatibility with
- * older parts of EmberData.
- *
-  @module
+* Utilities - often temporary - for maintaining backwards compatibility with
+* older parts of EmberData.
+*
+@module
 */
-export { SnapshotRecordArray } from './legacy-network-handler/snapshot-record-array.ts';
-export { SaveOp } from './legacy-network-handler/fetch-manager.ts';
-export { FetchManager } from './legacy-network-handler/fetch-manager.ts';
-export { Snapshot } from './legacy-network-handler/snapshot.ts';
+export { SnapshotRecordArray } from "./legacy-network-handler/snapshot-record-array.js";
+export { SaveOp } from "./legacy-network-handler/fetch-manager.js";
+export { FetchManager } from "./legacy-network-handler/fetch-manager.js";
+export { Snapshot } from "./legacy-network-handler/snapshot.js";
 export declare function upgradeStore(store: Store): asserts store is CompatStore;
-//# sourceMappingURL=-private.d.ts.map

package/declarations/compat/builders/find-all.d.ts

@@ -1,33 +1,35 @@
-import type { StoreRequestInput } from '@warp-drive/core';
-import type { FindAllOptions } from '@warp-drive/core/types';
-import type { TypedRecordInstance, TypeFromInstance } from '@warp-drive/core/types/record';
-import type { RequestSignature } from '@warp-drive/core/types/symbols';
-type FindAllRequestInput<T extends string = string, RT = unknown[]> = StoreRequestInput & {
-    op: 'findAll';
-    data: {
-        type: T;
-        options: FindAllBuilderOptions;
-    };
-    [RequestSignature]?: RT;
+import type { StoreRequestInput } from "@warp-drive/core";
+import type { FindAllOptions } from "@warp-drive/core/types";
+import type { TypedRecordInstance, TypeFromInstance } from "@warp-drive/core/types/record";
+import type { RequestSignature } from "@warp-drive/core/types/symbols";
+type FindAllRequestInput<
+	T extends string = string,
+	RT = unknown[]
+> = StoreRequestInput & {
+	op: "findAll";
+	data: {
+		type: T;
+		options: FindAllBuilderOptions;
+	};
+	[RequestSignature]?: RT;
 };
 type FindAllBuilderOptions<T = unknown> = FindAllOptions<T>;
 /**
-  This function builds a request config to perform a `findAll` request for the given type.
-  When passed to `store.request`, this config will result in the same behavior as a `store.findAll` request.
-  Additionally, it takes the same options as `store.findAll`.
+This function builds a request config to perform a `findAll` request for the given type.
+When passed to `store.request`, this config will result in the same behavior as a `store.findAll` request.
+Additionally, it takes the same options as `store.findAll`.
 
-  All `@ember-data/legacy-compat` builders exist to enable you to migrate your codebase to using the correct syntax for `store.request` while temporarily preserving legacy behaviors.
-  This is useful for quickly upgrading an entire app to a unified syntax while a longer incremental migration is made to shift off of adapters and serializers.
-  To that end, these builders are deprecated and will be removed in a future version of Ember Data.
+All `@ember-data/legacy-compat` builders exist to enable you to migrate your codebase to using the correct syntax for `store.request` while temporarily preserving legacy behaviors.
+This is useful for quickly upgrading an entire app to a unified syntax while a longer incremental migration is made to shift off of adapters and serializers.
+To that end, these builders are deprecated and will be removed in a future version of Ember Data.
 
-  @deprecated
-  @public
-  @param {String} type the name of the resource
-  @param {Object} query a query to be used by the adapter
-  @param {FindAllBuilderOptions} [options] optional, may include `adapterOptions` hash which will be passed to adapter.findAll
-  @return {FindAllRequestInput} request config
+@deprecated
+@public
+@param {String} type the name of the resource
+@param {Object} query a query to be used by the adapter
+@param {FindAllBuilderOptions} [options] optional, may include `adapterOptions` hash which will be passed to adapter.findAll
+@return {FindAllRequestInput} request config
 */
 export declare function findAllBuilder<T extends TypedRecordInstance>(type: TypeFromInstance<T>, options?: FindAllBuilderOptions<T>): FindAllRequestInput<TypeFromInstance<T>, T[]>;
 export declare function findAllBuilder(type: string, options?: FindAllBuilderOptions): FindAllRequestInput;
 export {};
-//# sourceMappingURL=find-all.d.ts.map

package/declarations/compat/builders/find-record.d.ts

@@ -1,54 +1,56 @@
-import type { StoreRequestInput } from '@warp-drive/core';
-import type { FindRecordOptions } from '@warp-drive/core/types';
-import type { TypedRecordInstance, TypeFromInstance } from '@warp-drive/core/types/record';
-import type { ResourceIdentifierObject } from '@warp-drive/core/types/spec/json-api-raw';
-import type { RequestSignature } from '@warp-drive/core/types/symbols';
-type FindRecordRequestInput<T extends string = string, RT = unknown> = StoreRequestInput & {
-    op: 'findRecord';
-    data: {
-        record: ResourceIdentifierObject<T>;
-        options: FindRecordBuilderOptions;
-    };
-    [RequestSignature]?: RT;
+import type { StoreRequestInput } from "@warp-drive/core";
+import type { FindRecordOptions } from "@warp-drive/core/types";
+import type { TypedRecordInstance, TypeFromInstance } from "@warp-drive/core/types/record";
+import type { ResourceIdentifierObject } from "@warp-drive/core/types/spec/json-api-raw";
+import type { RequestSignature } from "@warp-drive/core/types/symbols";
+type FindRecordRequestInput<
+	T extends string = string,
+	RT = unknown
+> = StoreRequestInput & {
+	op: "findRecord";
+	data: {
+		record: ResourceIdentifierObject<T>;
+		options: FindRecordBuilderOptions;
+	};
+	[RequestSignature]?: RT;
 };
-type FindRecordBuilderOptions = Omit<FindRecordOptions, 'preload'>;
+type FindRecordBuilderOptions = Omit<FindRecordOptions, "preload">;
 /**
-  This function builds a request config to find the record for a given identifier or type and id combination.
-  When passed to `store.request`, this config will result in the same behavior as a `store.findRecord` request.
-  Additionally, it takes the same options as `store.findRecord`, with the exception of `preload` (which is unsupported).
+This function builds a request config to find the record for a given identifier or type and id combination.
+When passed to `store.request`, this config will result in the same behavior as a `store.findRecord` request.
+Additionally, it takes the same options as `store.findRecord`, with the exception of `preload` (which is unsupported).
 
-  **Example 1**
+**Example 1**
 
-  ```ts
-  import { findRecord } from '@ember-data/legacy-compat/builders';
-  const { content: post } = await store.request<Post>(findRecord<Post>('post', '1'));
-  ```
+```ts
+import { findRecord } from '@ember-data/legacy-compat/builders';
+const { content: post } = await store.request<Post>(findRecord<Post>('post', '1'));
+```
 
-  **Example 2**
+**Example 2**
 
-  `findRecord` can be called with a single identifier argument instead of the combination
-  of `type` (modelName) and `id` as separate arguments. You may recognize this combo as
-  the typical pairing from [JSON:API](https://jsonapi.org/format/#document-resource-object-identification)
+`findRecord` can be called with a single identifier argument instead of the combination
+of `type` (modelName) and `id` as separate arguments. You may recognize this combo as
+the typical pairing from [JSON:API](https://jsonapi.org/format/#document-resource-object-identification)
 
-  ```ts
-  import { findRecord } from '@ember-data/legacy-compat/builders';
-  const { content: post } = await store.request<Post>(findRecord<Post>({ type: 'post', id }));
-  ```
+```ts
+import { findRecord } from '@ember-data/legacy-compat/builders';
+const { content: post } = await store.request<Post>(findRecord<Post>({ type: 'post', id }));
+```
 
-  All `@ember-data/legacy-compat` builders exist to enable you to migrate your codebase to using the correct syntax for `store.request` while temporarily preserving legacy behaviors.
-  This is useful for quickly upgrading an entire app to a unified syntax while a longer incremental migration is made to shift off of adapters and serializers.
-  To that end, these builders are deprecated and will be removed in a future version of Ember Data.
+All `@ember-data/legacy-compat` builders exist to enable you to migrate your codebase to using the correct syntax for `store.request` while temporarily preserving legacy behaviors.
+This is useful for quickly upgrading an entire app to a unified syntax while a longer incremental migration is made to shift off of adapters and serializers.
+To that end, these builders are deprecated and will be removed in a future version of Ember Data.
 
-  @deprecated
-  @public
-  @param {string|object} resource - either a string representing the name of the resource or a ResourceIdentifier object containing both the type (a string) and the id (a string) for the record or an lid (a string) of an existing record
-  @param {string|number|object} id - optional object with options for the request only if the first param is a ResourceIdentifier, else the string id of the record to be retrieved
-  @param {FindRecordBuilderOptions} [options] - if the first param is a string this will be the optional options for the request. See examples for available options.
-  @return {FindRecordRequestInput} request config
+@deprecated
+@public
+@param {string|object} resource - either a string representing the name of the resource or a ResourceIdentifier object containing both the type (a string) and the id (a string) for the record or an lid (a string) of an existing record
+@param {string|number|object} id - optional object with options for the request only if the first param is a ResourceIdentifier, else the string id of the record to be retrieved
+@param {FindRecordBuilderOptions} [options] - if the first param is a string this will be the optional options for the request. See examples for available options.
+@return {FindRecordRequestInput} request config
 */
 export declare function findRecordBuilder<T extends TypedRecordInstance>(type: TypeFromInstance<T>, id: string, options?: FindRecordBuilderOptions): FindRecordRequestInput<TypeFromInstance<T>, T>;
 export declare function findRecordBuilder(type: string, id: string, options?: FindRecordBuilderOptions): FindRecordRequestInput;
 export declare function findRecordBuilder<T extends TypedRecordInstance>(resource: ResourceIdentifierObject<TypeFromInstance<T>>, options?: FindRecordBuilderOptions): FindRecordRequestInput<TypeFromInstance<T>, T>;
 export declare function findRecordBuilder(resource: ResourceIdentifierObject, options?: FindRecordBuilderOptions): FindRecordRequestInput;
 export {};
-//# sourceMappingURL=find-record.d.ts.map

package/declarations/compat/builders/query.d.ts

@@ -1,61 +1,66 @@
-import type { StoreRequestInput } from '@warp-drive/core';
-import type { LegacyResourceQuery, QueryOptions } from '@warp-drive/core/types';
-import type { TypedRecordInstance, TypeFromInstance } from '@warp-drive/core/types/record';
-import type { RequestSignature } from '@warp-drive/core/types/symbols';
-type QueryRequestInput<T extends string = string, RT = unknown[]> = StoreRequestInput & {
-    op: 'query';
-    data: {
-        type: T;
-        query: LegacyResourceQuery;
-        options: QueryBuilderOptions;
-    };
-    [RequestSignature]?: RT;
+import type { StoreRequestInput } from "@warp-drive/core";
+import type { LegacyResourceQuery, QueryOptions } from "@warp-drive/core/types";
+import type { TypedRecordInstance, TypeFromInstance } from "@warp-drive/core/types/record";
+import type { RequestSignature } from "@warp-drive/core/types/symbols";
+type QueryRequestInput<
+	T extends string = string,
+	RT = unknown[]
+> = StoreRequestInput & {
+	op: "query";
+	data: {
+		type: T;
+		query: LegacyResourceQuery;
+		options: QueryBuilderOptions;
+	};
+	[RequestSignature]?: RT;
 };
 type QueryBuilderOptions = QueryOptions;
 /**
-  This function builds a request config for a given type and query object.
-  When passed to `store.request`, this config will result in the same behavior as a `store.query` request.
-  Additionally, it takes the same options as `store.query`.
+This function builds a request config for a given type and query object.
+When passed to `store.request`, this config will result in the same behavior as a `store.query` request.
+Additionally, it takes the same options as `store.query`.
 
-  All `@ember-data/legacy-compat` builders exist to enable you to migrate your codebase to using the correct syntax for `store.request` while temporarily preserving legacy behaviors.
-  This is useful for quickly upgrading an entire app to a unified syntax while a longer incremental migration is made to shift off of adapters and serializers.
-  To that end, these builders are deprecated and will be removed in a future version of Ember Data.
+All `@ember-data/legacy-compat` builders exist to enable you to migrate your codebase to using the correct syntax for `store.request` while temporarily preserving legacy behaviors.
+This is useful for quickly upgrading an entire app to a unified syntax while a longer incremental migration is made to shift off of adapters and serializers.
+To that end, these builders are deprecated and will be removed in a future version of Ember Data.
 
-  @deprecated
-  @public
-  @param {String} type the name of the resource
-  @param {Object} query a query to be used by the adapter
-  @param {QueryBuilderOptions} [options] optional, may include `adapterOptions` hash which will be passed to adapter.query
-  @return {QueryRequestInput} request config
+@deprecated
+@public
+@param {String} type the name of the resource
+@param {Object} query a query to be used by the adapter
+@param {QueryBuilderOptions} [options] optional, may include `adapterOptions` hash which will be passed to adapter.query
+@return {QueryRequestInput} request config
 */
 export declare function queryBuilder<T extends TypedRecordInstance>(type: TypeFromInstance<T>, query: LegacyResourceQuery<T>, options?: QueryBuilderOptions): QueryRequestInput<TypeFromInstance<T>, T[]>;
 export declare function queryBuilder(type: string, query: LegacyResourceQuery, options?: QueryBuilderOptions): QueryRequestInput;
-type QueryRecordRequestInput<T extends string = string, RT = unknown> = StoreRequestInput & {
-    op: 'queryRecord';
-    data: {
-        type: T;
-        query: LegacyResourceQuery;
-        options: QueryBuilderOptions;
-    };
-    [RequestSignature]?: RT;
+type QueryRecordRequestInput<
+	T extends string = string,
+	RT = unknown
+> = StoreRequestInput & {
+	op: "queryRecord";
+	data: {
+		type: T;
+		query: LegacyResourceQuery;
+		options: QueryBuilderOptions;
+	};
+	[RequestSignature]?: RT;
 };
 /**
-  This function builds a request config for a given type and query object.
-  When passed to `store.request`, this config will result in the same behavior as a `store.queryRecord` request.
-  Additionally, it takes the same options as `store.queryRecord`.
+This function builds a request config for a given type and query object.
+When passed to `store.request`, this config will result in the same behavior as a `store.queryRecord` request.
+Additionally, it takes the same options as `store.queryRecord`.
 
-  All `@ember-data/legacy-compat` builders exist to enable you to migrate your codebase to using the correct syntax for `store.request` while temporarily preserving legacy behaviors.
-  This is useful for quickly upgrading an entire app to a unified syntax while a longer incremental migration is made to shift off of adapters and serializers.
-  To that end, these builders are deprecated and will be removed in a future version of Ember Data.
+All `@ember-data/legacy-compat` builders exist to enable you to migrate your codebase to using the correct syntax for `store.request` while temporarily preserving legacy behaviors.
+This is useful for quickly upgrading an entire app to a unified syntax while a longer incremental migration is made to shift off of adapters and serializers.
+To that end, these builders are deprecated and will be removed in a future version of Ember Data.
 
-  @deprecated
-  @public
-  @param {String} type the name of the resource
-  @param {Object} query a query to be used by the adapter
-  @param {QueryBuilderOptions} [options] optional, may include `adapterOptions` hash which will be passed to adapter.query
-  @return {QueryRecordRequestInput} request config
+@deprecated
+@public
+@param {String} type the name of the resource
+@param {Object} query a query to be used by the adapter
+@param {QueryBuilderOptions} [options] optional, may include `adapterOptions` hash which will be passed to adapter.query
+@return {QueryRecordRequestInput} request config
 */
 export declare function queryRecordBuilder<T extends TypedRecordInstance>(type: TypeFromInstance<T>, query: LegacyResourceQuery<T>, options?: QueryBuilderOptions): QueryRecordRequestInput<TypeFromInstance<T>, T | null>;
 export declare function queryRecordBuilder(type: string, query: LegacyResourceQuery, options?: QueryBuilderOptions): QueryRecordRequestInput;
 export {};
-//# sourceMappingURL=query.d.ts.map

package/declarations/compat/builders/save-record.d.ts

@@ -1,32 +1,34 @@
-import { type StoreRequestInput } from '@warp-drive/core';
-import type { StableRecordIdentifier } from '@warp-drive/core/types';
-import type { TypedRecordInstance, TypeFromInstance } from '@warp-drive/core/types/record';
-import type { RequestSignature } from '@warp-drive/core/types/symbols';
-type SaveRecordRequestInput<T extends string = string, RT = unknown> = StoreRequestInput & {
-    op: 'createRecord' | 'deleteRecord' | 'updateRecord';
-    data: {
-        record: StableRecordIdentifier<T>;
-        options: SaveRecordBuilderOptions;
-    };
-    records: [StableRecordIdentifier<T>];
-    [RequestSignature]?: RT;
+import { type StoreRequestInput } from "@warp-drive/core";
+import type { StableRecordIdentifier } from "@warp-drive/core/types";
+import type { TypedRecordInstance, TypeFromInstance } from "@warp-drive/core/types/record";
+import type { RequestSignature } from "@warp-drive/core/types/symbols";
+type SaveRecordRequestInput<
+	T extends string = string,
+	RT = unknown
+> = StoreRequestInput & {
+	op: "createRecord" | "deleteRecord" | "updateRecord";
+	data: {
+		record: StableRecordIdentifier<T>;
+		options: SaveRecordBuilderOptions;
+	};
+	records: [StableRecordIdentifier<T>];
+	[RequestSignature]?: RT;
 };
 type SaveRecordBuilderOptions = Record<string, unknown>;
 /**
-  This function builds a request config for saving the given record (e.g. creating, updating, or deleting the record).
-  When passed to `store.request`, this config will result in the same behavior as a legacy `store.saveRecord` request.
-  Additionally, it takes the same options as `store.saveRecord`.
+This function builds a request config for saving the given record (e.g. creating, updating, or deleting the record).
+When passed to `store.request`, this config will result in the same behavior as a legacy `store.saveRecord` request.
+Additionally, it takes the same options as `store.saveRecord`.
 
-  All `@ember-data/legacy-compat` builders exist to enable you to migrate your codebase to using the correct syntax for `store.request` while temporarily preserving legacy behaviors.
-  This is useful for quickly upgrading an entire app to a unified syntax while a longer incremental migration is made to shift off of adapters and serializers.
-  To that end, these builders are deprecated and will be removed in a future version of Ember Data.
+All `@ember-data/legacy-compat` builders exist to enable you to migrate your codebase to using the correct syntax for `store.request` while temporarily preserving legacy behaviors.
+This is useful for quickly upgrading an entire app to a unified syntax while a longer incremental migration is made to shift off of adapters and serializers.
+To that end, these builders are deprecated and will be removed in a future version of Ember Data.
 
-  @deprecated
-  @public
-  @param {Object} record a record to save
-  @param {SaveRecordBuilderOptions} options optional, may include `adapterOptions` hash which will be passed to adapter.saveRecord
-  @return {SaveRecordRequestInput} request config
+@deprecated
+@public
+@param {Object} record a record to save
+@param {SaveRecordBuilderOptions} options optional, may include `adapterOptions` hash which will be passed to adapter.saveRecord
+@return {SaveRecordRequestInput} request config
 */
 export declare function saveRecordBuilder<T extends TypedRecordInstance>(record: T, options?: Record<string, unknown>): SaveRecordRequestInput<TypeFromInstance<T>, T>;
 export {};
-//# sourceMappingURL=save-record.d.ts.map

package/declarations/compat/builders/utils.d.ts

@@ -1,4 +1,3 @@
-import type { ResourceIdentifierObject } from '@warp-drive/core/types/spec/json-api-raw';
+import type { ResourceIdentifierObject } from "@warp-drive/core/types/spec/json-api-raw";
 export declare function isMaybeIdentifier(maybeIdentifier: string | ResourceIdentifierObject): maybeIdentifier is ResourceIdentifierObject;
 export declare function normalizeModelName(type: string): string;
-//# sourceMappingURL=utils.d.ts.map

package/declarations/compat/builders.d.ts

@@ -1,15 +1,14 @@
 /**
-  Builders for migrating from `store` methods to `store.request`.
+Builders for migrating from `store` methods to `store.request`.
 
-  These builders enable you to migrate your codebase to using the correct syntax for `store.request` while temporarily preserving legacy behaviors.
-  This is useful for quickly upgrading an entire app to a unified syntax while a longer incremental migration is made to shift off of adapters and serializers.
-  To that end, these builders are deprecated and will be removed in a future version of Ember Data.
+These builders enable you to migrate your codebase to using the correct syntax for `store.request` while temporarily preserving legacy behaviors.
+This is useful for quickly upgrading an entire app to a unified syntax while a longer incremental migration is made to shift off of adapters and serializers.
+To that end, these builders are deprecated and will be removed in a future version of Ember Data.
 
-  @module
-  @deprecated
+@module
+@deprecated
 */
-export { findAllBuilder as findAll } from './builders/find-all.ts';
-export { findRecordBuilder as findRecord } from './builders/find-record.ts';
-export { queryBuilder as query, queryRecordBuilder as queryRecord } from './builders/query.ts';
-export { saveRecordBuilder as saveRecord } from './builders/save-record.ts';
-//# sourceMappingURL=builders.d.ts.map
+export { findAllBuilder as findAll } from "./builders/find-all.js";
+export { findRecordBuilder as findRecord } from "./builders/find-record.js";
+export { queryBuilder as query, queryRecordBuilder as queryRecord } from "./builders/query.js";
+export { saveRecordBuilder as saveRecord } from "./builders/save-record.js";

package/declarations/compat/extensions.d.ts

@@ -1,113 +1,59 @@
-import { type default as EmberObject } from '@ember/object';
+import { type default as EmberObject } from "@ember/object";
+import type { CAUTION_MEGA_DANGER_ZONE_Extension } from "@warp-drive/core/reactive/-private/schema";
 declare const EmberObjectMethods: readonly ["addObserver", "cacheFor", "decrementProperty", "get", "getProperties", "incrementProperty", "notifyPropertyChange", "removeObserver", "set", "setProperties", "toggleProperty"];
-export declare const EmberObjectArrayExtension: {
-    kind: "array";
-    name: "ember-object";
-    features: {};
-};
-export declare const EmberObjectExtension: {
-    kind: "object";
-    name: "ember-object";
-    features: {};
-};
+export declare const EmberObjectArrayExtension: CAUTION_MEGA_DANGER_ZONE_Extension;
+export declare const EmberObjectExtension: CAUTION_MEGA_DANGER_ZONE_Extension;
 declare const EmberArrayLikeFeatures: {
-    addObject<T>(this: T[], obj: T): T[];
-    addObjects<T>(this: T[], objs: T[]): T[];
-    popObject<T>(this: T[]): T | undefined;
-    pushObject<T>(this: T[], obj: T): T;
-    pushObjects<T>(this: T[], objs: T[]): T[];
-    shiftObject<T>(this: T[]): NonNullable<T>;
-    unshiftObject<T>(this: T[], obj: T): T;
-    unshiftObjects<T>(this: T[], objs: T[]): T[];
-    objectAt<T>(this: T[], index: number): T;
-    objectsAt<T>(this: T[], indices: number[]): any[];
-    removeAt<T>(this: T[], index: number): T[];
-    insertAt<T>(this: T[], index: number, obj: T): T[];
-    removeObject<T>(this: T[], obj: T): T[];
-    removeObjects<T>(this: T[], objs: T[]): T[];
-    toArray<T>(this: T[]): T[];
-    replace<T>(this: T[], idx: number, amt: number, objects?: T[]): void;
-    clear<T>(this: T[]): T[];
-    setObjects<T>(this: T[], objects: T[]): T[];
-    reverseObjects<T>(this: T[]): T[];
-    compact<T>(this: T[]): (T & {})[];
-    any<T>(this: T[], callback: any, target: any): boolean;
-    isAny<T>(this: T[], prop: string, value: unknown): boolean;
-    isEvery<T>(this: T[], prop: string, value: unknown): boolean;
-    getEach<T>(this: T[], key: string): unknown[];
-    mapBy<T>(this: T[], key: string): unknown[];
-    findBy<T>(this: T[], key: string, value?: unknown): T | undefined;
-    filterBy<T>(this: T[], key: string, value?: unknown): T[];
-    sortBy<T>(this: T[], ...sortKeys: string[]): T[];
-    invoke<T>(this: T[], key: string, ...args: unknown[]): unknown[];
-    addArrayObserver<T>(this: T[]): void;
-    removeArrayObserver<T>(this: T[]): void;
-    arrayContentWillChange<T>(this: T[]): void;
-    arrayContentDidChange<T>(this: T[]): void;
-    reject<T>(this: T[], callback: any, target?: unknown): T[];
-    rejectBy<T>(this: T[], key: string, value?: unknown): T[];
-    setEach<T>(this: T[], key: string, value: unknown): void;
-    uniq<T>(this: T[]): T[];
-    uniqBy<T>(this: T[], key: string): T[];
-    without<T>(this: T[], value: T): T[];
-    readonly firstObject: unknown;
-    readonly lastObject: unknown;
-};
-export declare const EmberArrayLikeExtension: {
-    kind: "array";
-    name: "ember-array-like";
-    features: {
-        addObject<T>(this: T[], obj: T): T[];
-        addObjects<T>(this: T[], objs: T[]): T[];
-        popObject<T>(this: T[]): T | undefined;
-        pushObject<T>(this: T[], obj: T): T;
-        pushObjects<T>(this: T[], objs: T[]): T[];
-        shiftObject<T>(this: T[]): NonNullable<T>;
-        unshiftObject<T>(this: T[], obj: T): T;
-        unshiftObjects<T>(this: T[], objs: T[]): T[];
-        objectAt<T>(this: T[], index: number): T;
-        objectsAt<T>(this: T[], indices: number[]): any[];
-        removeAt<T>(this: T[], index: number): T[];
-        insertAt<T>(this: T[], index: number, obj: T): T[];
-        removeObject<T>(this: T[], obj: T): T[];
-        removeObjects<T>(this: T[], objs: T[]): T[];
-        toArray<T>(this: T[]): T[];
-        replace<T>(this: T[], idx: number, amt: number, objects?: T[]): void;
-        clear<T>(this: T[]): T[];
-        setObjects<T>(this: T[], objects: T[]): T[];
-        reverseObjects<T>(this: T[]): T[];
-        compact<T>(this: T[]): (T & {})[];
-        any<T>(this: T[], callback: any, target: any): boolean;
-        isAny<T>(this: T[], prop: string, value: unknown): boolean;
-        isEvery<T>(this: T[], prop: string, value: unknown): boolean;
-        getEach<T>(this: T[], key: string): unknown[];
-        mapBy<T>(this: T[], key: string): unknown[];
-        findBy<T>(this: T[], key: string, value?: unknown): T | undefined;
-        filterBy<T>(this: T[], key: string, value?: unknown): T[];
-        sortBy<T>(this: T[], ...sortKeys: string[]): T[];
-        invoke<T>(this: T[], key: string, ...args: unknown[]): unknown[];
-        addArrayObserver<T>(this: T[]): void;
-        removeArrayObserver<T>(this: T[]): void;
-        arrayContentWillChange<T>(this: T[]): void;
-        arrayContentDidChange<T>(this: T[]): void;
-        reject<T>(this: T[], callback: any, target?: unknown): T[];
-        rejectBy<T>(this: T[], key: string, value?: unknown): T[];
-        setEach<T>(this: T[], key: string, value: unknown): void;
-        uniq<T>(this: T[]): T[];
-        uniqBy<T>(this: T[], key: string): T[];
-        without<T>(this: T[], value: T): T[];
-        readonly firstObject: unknown;
-        readonly lastObject: unknown;
-    };
+	addObject<T>(this: T[], obj: T): T[];
+	addObjects<T>(this: T[], objs: T[]): T[];
+	popObject<T>(this: T[]): T | undefined;
+	pushObject<T>(this: T[], obj: T): T;
+	pushObjects<T>(this: T[], objs: T[]): T[];
+	shiftObject<T>(this: T[]): NonNullable<T>;
+	unshiftObject<T>(this: T[], obj: T): T;
+	unshiftObjects<T>(this: T[], objs: T[]): T[];
+	objectAt<T>(this: T[], index: number): T;
+	objectsAt<T>(this: T[], indices: number[]): T[];
+	removeAt<T>(this: T[], index: number): T[];
+	insertAt<T>(this: T[], index: number, obj: T): T[];
+	removeObject<T>(this: T[], obj: T): T[];
+	removeObjects<T>(this: T[], objs: T[]): T[];
+	toArray<T>(this: T[]): T[];
+	replace<T>(this: T[], idx: number, amt: number, objects?: T[]): void;
+	clear<T>(this: T[]): T[];
+	setObjects<T>(this: T[], objects: T[]): T[];
+	reverseObjects<T>(this: T[]): T[];
+	compact<T>(this: T[]): (T & {})[];
+	any<T>(this: T[], callback: Parameters<Array<T>["some"]>[0], target?: unknown): boolean;
+	isAny<T>(this: T[], prop: string, value: unknown): boolean;
+	isEvery<T>(this: T[], prop: string, value: unknown): boolean;
+	getEach<T>(this: T[], key: string): unknown[];
+	mapBy<T>(this: T[], key: string): unknown[];
+	findBy<T>(this: T[], key: string, value?: unknown): T | undefined;
+	filterBy<T>(this: T[], key: string, value?: unknown): T[];
+	sortBy<T>(this: T[], ...sortKeys: string[]): T[];
+	invoke<T>(this: T[], key: string, ...args: unknown[]): unknown[];
+	addArrayObserver<T>(this: T[]): void;
+	removeArrayObserver<T>(this: T[]): void;
+	arrayContentWillChange<T>(this: T[]): void;
+	arrayContentDidChange<T>(this: T[]): void;
+	reject<T>(this: T[], callback: Parameters<Array<T>["filter"]>[0], target?: unknown): T[];
+	rejectBy<T>(this: T[], key: string, value?: unknown): T[];
+	setEach<T>(this: T[], key: string, value: unknown): void;
+	uniq<T>(this: T[]): T[];
+	uniqBy<T>(this: T[], key: string): T[];
+	without<T>(this: T[], value: T): T[];
+	firstObject: unknown;
+	lastObject: unknown;
 };
+export declare const EmberArrayLikeExtension: CAUTION_MEGA_DANGER_ZONE_Extension;
 export type ArrayType<T> = T extends ReadonlyArray<infer U> ? U : never;
 export type WithEmberObject<T> = T & Pick<T & EmberObject, ArrayType<typeof EmberObjectMethods>>;
-export type WithArrayLike<T> = T extends Array<infer U> ? U & Omit<typeof EmberArrayLikeFeatures, 'firstObject' | 'lastObject'> & {
-    firstObject: T | undefined;
-    lastObject: T | undefined;
-} : T[] & Omit<typeof EmberArrayLikeFeatures, 'firstObject' | 'lastObject'> & {
-    firstObject: T | undefined;
-    lastObject: T | undefined;
+export type WithArrayLike<T> = T extends Array<infer U> ? U & Omit<typeof EmberArrayLikeFeatures, "firstObject" | "lastObject"> & {
+	firstObject: T | undefined;
+	lastObject: T | undefined;
+} : T[] & Omit<typeof EmberArrayLikeFeatures, "firstObject" | "lastObject"> & {
+	firstObject: T | undefined;
+	lastObject: T | undefined;
 };
 export {};
-//# sourceMappingURL=extensions.d.ts.map