@warp-drive/legacy 5.9.0-alpha.21 → 5.9.0-alpha.22

package/declarations/adapter/error.d.ts

@@ -1,431 +0,0 @@
-import type { ApiError } from "@warp-drive/core/types/spec/error";
-/**
-* The shape of the errors thrown/returned by {@link AdapterError} and its subclasses.
-*/
-export interface AdapterRequestError<T extends string = string> extends Error {
-	/**
-	* A property signifying that an Error uses the {@link AdapterRequestError} interface.
-	*/
-	isAdapterError: true;
-	/**
-	* A short code identifying the kind of error, e.g. `'NotFoundError'`.
-	*/
-	code: T;
-	/**
-	* The {json:api} formatted errors associated with the request.
-	*/
-	errors: ApiError[];
-}
-/**
-* The static interface shared by {@link AdapterError} and its subclasses,
-* allowing further subclassing via {@link AdapterRequestErrorConstructor.extend | extend}.
-*/
-export interface AdapterRequestErrorConstructor<Instance extends AdapterRequestError = AdapterRequestError> {
-	new (errors?: unknown[], message?: string): Instance;
-	/**
-	* Creates a new {@link AdapterRequestErrorConstructor} that inherits from this one.
-	*/
-	extend(options: {
-		message: string;
-	}): AdapterRequestErrorConstructor;
-}
-/**
-* The {@link AdapterRequestError} shape thrown by the {@link AdapterError} constructor.
-*/
-export type AdapterError = AdapterRequestError<"AdapterError">;
-/**
-* :::danger
-* ⚠️ **This is LEGACY documentation** for a feature that is no longer encouraged to be used.
-* If starting a new app or thinking of implementing a new adapter, consider writing a
-* {@link Handler} instead to be used with the {@link RequestManager}
-* :::
-*
-* An `AdapterError` is used by an adapter to signal that an error occurred
-* during a request to an external API. It indicates a generic error, and
-* subclasses are used to indicate specific error states.
-*
-* To create a custom error to signal a specific error state in communicating
-* with an external API, extend the `AdapterError`. For example, if the
-* external API exclusively used HTTP `503 Service Unavailable` to indicate
-* it was closed for maintenance:
-*
-* ```js [app/adapters/maintenance-error.js]
-* import AdapterError from '@warp-drive/legacy/adapter/error';
-*
-* export default AdapterError.extend({ message: "Down for maintenance." });
-* ```
-*
-* This error would then be returned by an adapter's `handleResponse` method:
-*
-* ```js [app/adapters/application.js]
-* import JSONAPIAdapter from '@warp-drive/legacy/adapter/json-api';
-* import MaintenanceError from './maintenance-error';
-*
-* export default class ApplicationAdapter extends JSONAPIAdapter {
-*   handleResponse(status) {
-*     if (503 === status) {
-*       return new MaintenanceError();
-*     }
-*
-*     return super.handleResponse(...arguments);
-*   }
-* }
-* ```
-*
-* And can then be detected in an application and used to send the user to an
-* `under-maintenance` route:
-*
-* ```js [app/routes/application.js]
-* import MaintenanceError from '../adapters/maintenance-error';
-*
-* export default class ApplicationRoute extends Route {
-*   actions: {
-*     error(error, transition) {
-*       if (error instanceof MaintenanceError) {
-*         this.transitionTo('under-maintenance');
-*         return;
-*       }
-*
-*       // ...other error handling logic
-*     }
-*   }
-* }
-* ```
-*
-* ### Signaling an Error Without Extending `AdapterError`
-*
-* Extending `AdapterError` (or one of its subclasses) is a convenience, not
-* a requirement. WarpDrive only inspects an error for the {@link AdapterRequestError}
-* shape: an `isAdapterError` flag, a `code`, and an {json:api}-formatted
-* `errors` array. Any object satisfying that shape — including a plain
-* `Error` with those properties attached — will be handled identically to
-* an instance created via `new AdapterError()` or one of its subclasses.
-*
-* This is useful when you'd rather not introduce a class hierarchy, or
-* when the error needs to be constructed from data you don't control
-* (for example, re-throwing an error surfaced by a third-party library):
-*
-* ```js [app/adapters/application.js]
-* import JSONAPIAdapter from '@warp-drive/legacy/adapter/json-api';
-*
-* export default class ApplicationAdapter extends JSONAPIAdapter {
-*   handleResponse(status, headers, payload) {
-*     if (status === 503) {
-*       const error = new Error('Down for maintenance.');
-*       error.isAdapterError = true;
-*       error.code = 'MaintenanceError';
-*       error.errors = [{ title: 'Service Unavailable', detail: 'Down for maintenance.' }];
-*       return error;
-*     }
-*
-*     return super.handleResponse(status, headers, payload);
-*   }
-* }
-* ```
-*
-* Because `code` is just a string you control, `error instanceof AdapterError`
-* checks won't match a plain object built this way — consumers should
-* instead branch on `error.isAdapterError && error.code === 'MaintenanceError'`,
-* or on whichever of the {@link AdapterError} subclasses' `code` values
-* (e.g. `'InvalidError'`, `'NotFoundError'`) the error's `code` matches.
-*
-* @public
-*/
-export declare const AdapterError: AdapterRequestErrorConstructor<AdapterError>;
-/**
-* The {@link AdapterRequestError} shape thrown by the {@link InvalidError} constructor.
-*/
-export type InvalidError = AdapterRequestError<"InvalidError">;
-/**
-* An `InvalidError` is used by an adapter to signal that the external API
-* was unable to process a request because the content was not semantically
-* correct or meaningful per the API. Usually, this means a record failed
-* some form of server-side validation. When a promise from an adapter is
-* rejected with an `InvalidError` the record will transition to the
-* `invalid` state and the errors will be set to the `errors` property on
-* the record.
-*
-* For WarpDrive to correctly map errors to their corresponding properties
-* on the model, WarpDrive expects each error to be a valid {json:api} error
-* object with a `source.pointer` that matches the property name. For
-* example, if you had a `Post` model that looked like this:
-*
-* ```js [app/models/post.js]
-* import { Model, attr } from '@warp-drive/legacy/model';
-*
-* export default class PostModel extends Model {
-*   @attr('string') title;
-*   @attr('string') content;
-* }
-* ```
-*
-* To show an error from the server related to the `title` and `content`
-* properties your adapter could return a promise that rejects with an
-* `InvalidError` that looks like this:
-*
-* ```js [app/adapters/post.js]
-* import RSVP from 'RSVP';
-* import RESTAdapter from '@warp-drive/legacy/adapter/rest';
-* import { InvalidError } from '@warp-drive/legacy/adapter/error';
-*
-* export default class ApplicationAdapter extends RESTAdapter {
-*   updateRecord() {
-*     // Fictional adapter that always rejects
-*     return RSVP.reject(new InvalidError([
-*       {
-*         detail: 'Must be unique',
-*         source: { pointer: '/data/attributes/title' }
-*       },
-*       {
-*         detail: 'Must not be blank',
-*         source: { pointer: '/data/attributes/content' }
-*       }
-*     ]));
-*   }
-* }
-* ```
-*
-* Your backend may use different property names for your records; the
-* store will attempt to extract and normalize the errors using the
-* serializer's `extractErrors` method before the errors get added to the
-* model. As a result, it is safe for the `InvalidError` to wrap the error
-* payload unaltered.
-*
-* @public
-*/
-export declare const InvalidError: AdapterRequestErrorConstructor<InvalidError>;
-/**
-* The {@link AdapterRequestError} shape thrown by the {@link TimeoutError} constructor.
-*/
-export type TimeoutError = AdapterRequestError<"TimeoutError">;
-/**
-* A `TimeoutError` is used by an adapter to signal that a request to the
-* external API has timed out, i.e. no response was received from the
-* external API within an allowed time period.
-*
-* An example use case would be to warn the user to check their internet
-* connection if an adapter operation has timed out:
-*
-* ```js [app/routes/application.js]
-* import { TimeoutError } from '@warp-drive/legacy/adapter/error';
-*
-* export default class ApplicationRoute extends Route {
-*   @action
-*   error(error, transition) {
-*     if (error instanceof TimeoutError) {
-*       // alert the user
-*       alert('Are you still connected to the Internet?');
-*       return;
-*     }
-*
-*     // ...other error handling logic
-*   }
-* }
-* ```
-*
-* @public
-*/
-export declare const TimeoutError: AdapterRequestErrorConstructor<TimeoutError>;
-/**
-* The {@link AdapterRequestError} shape thrown by the {@link AbortError} constructor.
-*/
-export type AbortError = AdapterRequestError<"AbortError">;
-/**
-* An `AbortError` is used by an adapter to signal that a request to the
-* external API was aborted. For example, this can occur if the user
-* navigates away from the current page after a request to the external API
-* has been initiated but before a response has been received.
-*
-* Because an aborted request is typically expected (the user chose to
-* navigate away, or a newer request superseded this one) rather than
-* exceptional, an example use case would be to silently ignore it instead
-* of surfacing an error to the user:
-*
-* ```js [app/routes/application.js]
-* import { AbortError } from '@warp-drive/legacy/adapter/error';
-*
-* export default class ApplicationRoute extends Route {
-*   @action
-*   error(error, transition) {
-*     if (error instanceof AbortError) {
-*       // the request was aborted, nothing to report
-*       return;
-*     }
-*
-*     // ...other error handling logic
-*   }
-* }
-* ```
-*
-* @public
-*/
-export declare const AbortError: AdapterRequestErrorConstructor<AbortError>;
-/**
-* The {@link AdapterRequestError} shape thrown by the {@link UnauthorizedError} constructor.
-*/
-export type UnauthorizedError = AdapterRequestError<"UnauthorizedError">;
-/**
-* A `UnauthorizedError` equates to an HTTP `401 Unauthorized` response
-* status. It is used by an adapter to signal that a request to the external
-* API was rejected because authorization is required and has failed or has
-* not yet been provided.
-*
-* An example use case would be to redirect the user to a login route if a
-* request is unauthorized:
-*
-* ```js [app/routes/application.js]
-* import { UnauthorizedError } from '@warp-drive/legacy/adapter/error';
-*
-* export default class ApplicationRoute extends Route {
-*   @action
-*   error(error, transition) {
-*     if (error instanceof UnauthorizedError) {
-*       // go to the login route
-*       this.transitionTo('login');
-*       return;
-*     }
-*
-*     // ...other error handling logic
-*   }
-* }
-* ```
-*
-* @public
-*/
-export declare const UnauthorizedError: AdapterRequestErrorConstructor<UnauthorizedError>;
-/**
-* The {@link AdapterRequestError} shape thrown by the {@link ForbiddenError} constructor.
-*/
-export type ForbiddenError = AdapterRequestError<"ForbiddenError">;
-/**
-* A `ForbiddenError` equates to an HTTP `403 Forbidden` response status.
-* It is used by an adapter to signal that a request to the external API was
-* valid but the server is refusing to respond to it. If authorization was
-* provided and is valid, then the authenticated user does not have the
-* necessary permissions for the request.
-*
-* Unlike an {@link UnauthorizedError}, retrying the request with different
-* credentials will not help; the currently authenticated user simply lacks
-* permission. An example use case would be to show the user a "you don't
-* have access to this" message rather than redirecting them to log in:
-*
-* ```js [app/routes/application.js]
-* import { ForbiddenError } from '@warp-drive/legacy/adapter/error';
-*
-* export default class ApplicationRoute extends Route {
-*   @action
-*   error(error, transition) {
-*     if (error instanceof ForbiddenError) {
-*       this.transitionTo('forbidden');
-*       return;
-*     }
-*
-*     // ...other error handling logic
-*   }
-* }
-* ```
-*
-* @public
-*/
-export declare const ForbiddenError: AdapterRequestErrorConstructor<ForbiddenError>;
-/**
-* The {@link AdapterRequestError} shape thrown by the {@link NotFoundError} constructor.
-*/
-export type NotFoundError = AdapterRequestError<"NotFoundError">;
-/**
-* A `NotFoundError` equates to an HTTP `404 Not Found` response status.
-* It is used by an adapter to signal that a request to the external API
-* was rejected because the resource could not be found on the API.
-*
-* An example use case would be to detect if the user has entered a route
-* for a specific model that does not exist. For example:
-*
-* ```js [app/routes/post.js]
-* import { NotFoundError } from '@warp-drive/legacy/adapter/error';
-*
-* export default class PostRoute extends Route {
-*   @service store;
-*   model(params) {
-*     return this.store.findRecord('post', params.post_id);
-*   }
-*   @action
-*   error(error, transition) {
-*     if (error instanceof NotFoundError) {
-*       // redirect to a list of all posts instead
-*       this.transitionTo('posts');
-*     } else {
-*       // otherwise let the error bubble
-*       return true;
-*     }
-*   }
-* }
-* ```
-*
-* @public
-*/
-export declare const NotFoundError: AdapterRequestErrorConstructor<NotFoundError>;
-/**
-* The {@link AdapterRequestError} shape thrown by the {@link ConflictError} constructor.
-*/
-export type ConflictError = AdapterRequestError<"ConflictError">;
-/**
-* A `ConflictError` equates to an HTTP `409 Conflict` response status.
-* It is used by an adapter to indicate that the request could not be
-* processed because of a conflict in the request. An example scenario
-* would be when creating a record with a client-generated ID but that ID
-* is already known to the external API.
-*
-* An example use case would be to surface a conflict-specific message so
-* the user can retry with different input:
-*
-* ```js [app/routes/application.js]
-* import { ConflictError } from '@warp-drive/legacy/adapter/error';
-*
-* export default class ApplicationRoute extends Route {
-*   @action
-*   error(error, transition) {
-*     if (error instanceof ConflictError) {
-*       alert('That identifier is already in use, please choose another.');
-*       return;
-*     }
-*
-*     // ...other error handling logic
-*   }
-* }
-* ```
-*
-* @public
-*/
-export declare const ConflictError: AdapterRequestErrorConstructor<ConflictError>;
-/**
-* The {@link AdapterRequestError} shape thrown by the {@link ServerError} constructor.
-*/
-export type ServerError = AdapterRequestError<"ServerError">;
-/**
-* A `ServerError` equates to an HTTP `500 Internal Server Error` response
-* status. It is used by the adapter to indicate that a request has failed
-* because of an error in the external API, and is unlikely to succeed if
-* retried immediately.
-*
-* An example use case would be to show a generic "something went wrong on
-* our end" message rather than one implying the user made a mistake:
-*
-* ```js [app/routes/application.js]
-* import { ServerError } from '@warp-drive/legacy/adapter/error';
-*
-* export default class ApplicationRoute extends Route {
-*   @action
-*   error(error, transition) {
-*     if (error instanceof ServerError) {
-*       alert('Something went wrong on our end. Please try again later.');
-*       return;
-*     }
-*
-*     // ...other error handling logic
-*   }
-* }
-* ```
-*
-* @public
-*/
-export declare const ServerError: AdapterRequestErrorConstructor<ServerError>;

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

@@ -1,13 +0,0 @@
-import type { Store } from "@warp-drive/core";
-import type { CompatStore } from "../compat.js";
-/**
-* Utilities - often temporary - for maintaining backwards compatibility with
-* older parts of WarpDrive.
-*
-@module
-*/
-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;

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

@@ -1,34 +0,0 @@
-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 = FindAllOptions;
-/**
-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 `@warp-drive/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 WarpDrive.
-
-@deprecated
-@public
-@param type the name of the resource
-@param options optional, may include `adapterOptions` hash which will be passed to adapter.findAll
-@return request config
-*/
-export declare function findAllBuilder<T extends TypedRecordInstance>(type: TypeFromInstance<T>, options?: FindAllBuilderOptions): FindAllRequestInput<TypeFromInstance<T>, T[]>;
-export declare function findAllBuilder(type: string, options?: FindAllBuilderOptions): FindAllRequestInput;
-export {};

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

@@ -1,56 +0,0 @@
-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">;
-/**
-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**
-
-```ts
-import { findRecord } from '@warp-drive/legacy/compat/builders';
-const { content: post } = await store.request<Post>(findRecord<Post>('post', '1'));
-```
-
-**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)
-
-```ts
-import { findRecord } from '@warp-drive/legacy/compat/builders';
-const { content: post } = await store.request<Post>(findRecord<Post>({ type: 'post', id }));
-```
-
-All `@warp-drive/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 Warp Drive.
-
-@deprecated
-@public
-@param 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 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 options - if the first param is a string this will be the optional options for the request. See examples for available options.
-@return 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 {};

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

@@ -1,66 +0,0 @@
-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`.
-
-All `@warp-drive/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 WarpDrive.
-
-@deprecated
-@public
-@param type the name of the resource
-@param query a query to be used by the adapter
-@param options optional, may include `adapterOptions` hash which will be passed to adapter.query
-@return request config
-*/
-export declare function queryBuilder<T extends TypedRecordInstance>(type: TypeFromInstance<T>, query: LegacyResourceQuery, 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;
-};
-/**
-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 `@warp-drive/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 WarpDrive.
-
-@deprecated
-@public
-@param type the name of the resource
-@param query a query to be used by the adapter
-@param options optional, may include `adapterOptions` hash which will be passed to adapter.query
-@return request config
-*/
-export declare function queryRecordBuilder<T extends TypedRecordInstance>(type: TypeFromInstance<T>, query: LegacyResourceQuery, options?: QueryBuilderOptions): QueryRecordRequestInput<TypeFromInstance<T>, T | null>;
-export declare function queryRecordBuilder(type: string, query: LegacyResourceQuery, options?: QueryBuilderOptions): QueryRecordRequestInput;
-export {};

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

@@ -1,34 +0,0 @@
-import { type StoreRequestInput } from "@warp-drive/core";
-import type { ResourceKey } 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: ResourceKey<T>;
-		options: SaveRecordBuilderOptions;
-	};
-	records: [ResourceKey<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`.
-
-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
-*/
-export declare function saveRecordBuilder<T extends TypedRecordInstance>(record: T, options?: Record<string, unknown>): SaveRecordRequestInput<TypeFromInstance<T>, T>;
-export {};

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

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

package/declarations/compat/builders.d.ts

@@ -1,14 +0,0 @@
-/**
-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.
-
-@module
-@deprecated
-*/
-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";