lumen-framework 3.0.3 → 3.1.1

package/dist/types/errors/namespaced-serializer-missing-error.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Thrown at boot when a namespace that opted out of serializer fallback
+ * (`serializerFallback = false` on its ApplicationController) can reach a type
+ * that has no Serializer in that namespace.
+ *
+ * @private
+ */
+declare class NamespacedSerializerMissingError extends ReferenceError {
+    /**
+     * @param missing - Each missing serializer key (`admin/comments`) with an
+     * example of how it is reached (`admin/posts?include=comments`).
+     */
+    constructor(missing: Map<string, string>);
+}
+export default NamespacedSerializerMissingError;

package/dist/types/packages/application/utils/validate-namespaced-serializers.d.ts

@@ -0,0 +1,15 @@
+import type Controller from '../../controller';
+import type Serializer from '../../serializer';
+import type { Model } from '../../database';
+import type { Bundle$Namespace } from '../../loader';
+/**
+ * Enforce `serializerFallback = false`: for every namespace whose
+ * ApplicationController sets it, each type its controllers can serialize — the
+ * resource itself, and everything reachable through `include` (and so
+ * `fields`) down to the controller's `maxIncludeDepth` — must have a
+ * Serializer in exactly that namespace. Throws listing every gap, so a missing
+ * serializer fails the boot instead of silently falling back to the root one.
+ *
+ * @private
+ */
+export default function validateNamespacedSerializers(controllers: Bundle$Namespace<Controller> | Map<string, Controller>, serializers: Bundle$Namespace<Serializer<Model>> | Map<string, Serializer<Model>>): void;

package/dist/types/packages/controller/errors/index.d.ts

@@ -0,0 +1 @@
+export { default as RelatedRecordNotFoundError } from './related-record-not-found-error';

package/dist/types/packages/controller/errors/related-record-not-found-error.d.ts

@@ -0,0 +1,14 @@
+import type { ModelClass } from '../../database';
+import type { Server$ErrorSource } from '../../server';
+/**
+ * JSON:API 1.0: "A server MUST return 404 Not Found when processing a request
+ * that references a related resource that does not exist."
+ *
+ * @private
+ */
+declare class RelatedRecordNotFoundError extends Error {
+    source: Server$ErrorSource;
+    constructor({ name, primaryKey }: ModelClass, primaryKeyValue: unknown, path: string);
+}
+declare const _default: new (...args: Array<any>) => RelatedRecordNotFoundError & import("../../server/interfaces").Server$Error;
+export default _default;

package/dist/types/packages/controller/index.d.ts

@@ -442,6 +442,71 @@ declare class Controller {
      * @public
      */
     defaultPerPage: number;
+    /**
+     * How many relationships deep an `?include` path may go on this
+     * controller's routes. `comments.reactions.user` is 3 levels deep; with `1`
+     * only direct relationships (`comments`) can be included. Paths deeper than
+     * this are rejected with `400 Bad Request`.
+     *
+     * Set it on `ApplicationController` to change it for the whole app, or on a
+     * single controller to override it there.
+     *
+     * ```javascript
+     * class ApplicationController extends Controller {
+     *   maxIncludeDepth = 2;
+     * }
+     * ```
+     *
+     * Every allowed path is enumerated up front from the serializers'
+     * relationships, and each nested level costs its own queries per request, so
+     * keep this small.
+     *
+     * @property maxIncludeDepth
+     * @type {Number}
+     * @default 3
+     * @public
+     */
+    maxIncludeDepth: number;
+    /**
+     * Whether a namespace may fall back to the root Serializer of a type it has
+     * no Serializer for. Read from a namespace's `ApplicationController` and
+     * applies to the whole namespace.
+     *
+     * By default `app/controllers/admin/comments.js` without an
+     * `app/serializers/admin/comments.js` — or an included type without one —
+     * is serialized by the root Serializer, with every attribute and
+     * relationship it declares. For a namespace that must only expose what it
+     * declares itself, turn the fallback off:
+     *
+     * ```javascript
+     * // app/controllers/admin/application.js
+     * class AdminApplicationController extends ApplicationController {
+     *   serializerFallback = false;
+     * }
+     * ```
+     *
+     * The application then refuses to boot while any type the namespace can
+     * serialize or `include` (down to each controller's `maxIncludeDepth`) has
+     * no Serializer in that namespace, listing each missing one.
+     *
+     * @property serializerFallback
+     * @type {Boolean}
+     * @default true
+     * @public
+     */
+    serializerFallback: boolean;
+    /**
+     * The Serializer to serialize (and validate, and load) related resources of
+     * this Controller's responses with: the related model's Serializer in this
+     * Controller's namespace, falling back to the root one.
+     *
+     * Always this Controller's namespace — not its Serializer's, which is the
+     * root one when the namespace has no Serializer for this resource.
+     *
+     * @method serializerFor
+     * @private
+     */
+    serializerFor(model: ModelClass): Serializer<Model>;
     /**
      * The resolved Model for a Controller instance.
      *

package/dist/types/packages/controller/utils/find-many.d.ts

@@ -1,6 +1,7 @@
 import type { Model, ModelClass, Query } from '../../database';
+import type Serializer from '../../serializer';
 import type { Request } from '../../server';
 /**
  * @private
  */
-export default function findMany<T extends Model>(model: ModelClass<T>, req: Request): Query<Array<Model>>;
+export default function findMany<T extends Model>(model: ModelClass<T>, req: Request, serializerFor?: (model: ModelClass) => Serializer<Model>): Query<Array<Model>>;

package/dist/types/packages/controller/utils/find-one.d.ts

@@ -1,6 +1,7 @@
 import type { Model, ModelClass, Query } from '../../database';
+import type Serializer from '../../serializer';
 import type { Request } from '../../server';
 /**
  * @private
  */
-export default function findOne<T extends Model>(model: ModelClass<T>, req: Request): Query<T>;
+export default function findOne<T extends Model>(model: ModelClass<T>, req: Request, serializerFor?: (model: ModelClass) => Serializer<Model>): Query<T>;

package/dist/types/packages/controller/utils/params-to-query.d.ts

@@ -1,4 +1,5 @@
-import type { ModelClass } from '../../database';
+import type { Model, ModelClass } from '../../database';
+import type Serializer from '../../serializer';
 import type { Request$params } from '../../server';
 type Controller$query = {
     id?: number | string | Buffer;
@@ -10,7 +11,11 @@ type Controller$query = {
     include: Record<string, Array<string>>;
 };
 /**
+ * `serializerFor` resolves the Serializer an included resource is serialized
+ * with — in the request's namespace (`Controller#serializerFor()`) — so its
+ * attributes are the ones loaded. Defaults to the related model's root one.
+ *
  * @private
  */
-export default function paramsToQuery(model: ModelClass, { id, page, sort, filter, fields, include }: Request$params): Controller$query;
+export default function paramsToQuery(model: ModelClass, { id, page, sort, filter, fields, include }: Request$params, serializerFor?: (related: ModelClass) => Serializer<Model>): Controller$query;
 export {};

package/dist/types/packages/controller/utils/validate-relationships.d.ts

@@ -0,0 +1,8 @@
+import type { Model, ModelClass } from '../../database';
+/**
+ * Check that every resource referenced from `data.relationships` exists, so a
+ * write cannot leave dangling linkage. One query per relationship.
+ *
+ * @private
+ */
+export default function validateRelationships<T extends Model>(model: ModelClass<T>, relationships?: Record<string, unknown>): Promise<void>;

package/dist/types/packages/database/constants.d.ts

@@ -1,3 +1,4 @@
+export declare const UNIQUE_CONSTRAINT_CODES: Set<string>;
 export declare const UNIQUE_CONSTRAINT: RegExp;
 export declare const VALID_DRIVERS: string[];
 export declare const TYPE_ALIASES: Map<string, string>;

package/dist/types/packages/database/model/index.d.ts

@@ -78,6 +78,17 @@ declare class Model {
      * @private
      */
     prevAssociations: Set<Model>;
+    /**
+     * Names of `hasOne` relationships that were eager-loaded (joined) and found
+     * to have no related record. Lets the relationship getter answer `null`
+     * without a per-record query. Kept outside of the change sets so it never
+     * counts as a change to the record.
+     *
+     * @property absentRelationships
+     * @type {Set}
+     * @private
+     */
+    absentRelationships: Set<string>;
     /**
      * @property changeSets
      * @type {Array}

package/dist/types/packages/database/model/utils/process-write-error.d.ts

@@ -1,4 +1,12 @@
 /**
+ * Map a database write error to the server error it should surface as.
+ *
  * @private
  */
-export default function resolveWriteError(err: Error): Error;
+export default function processWriteError(err: unknown): unknown;
+/**
+ * `.catch()` handler for a write: rethrows the mapped error.
+ *
+ * @private
+ */
+export declare function rethrowWriteError(err: unknown): never;

package/dist/types/packages/database/validation/errors/validation-error.d.ts

@@ -1,7 +1,16 @@
+import type { Server$ErrorSource } from '../../../server';
 /**
+ * A model validator (`static validates`) rejected an attribute. Answered with
+ * 422 and a pointer to the attribute, which clients such as ember-data map to
+ * field errors. The rejected value is deliberately not in the message: it
+ * ends up in logs and may be a secret (e.g. a password).
+ *
  * @private
  */
 declare class ValidationError extends Error {
-    constructor(key: string, value: string);
+    key: string;
+    source: Server$ErrorSource;
+    constructor(key: string);
 }
-export default ValidationError;
+declare const _default: new (...args: Array<any>) => ValidationError & import("../../../server/interfaces").Server$Error;
+export default _default;

package/dist/types/packages/jsonapi/interfaces.d.ts

@@ -28,7 +28,7 @@ export interface JSONAPI$ResourceObject {
     };
 }
 export interface JSONAPI$RelationshipObject {
-    data: JSONAPI$IdentifierObject;
+    data: JSONAPI$IdentifierObject | Array<JSONAPI$IdentifierObject> | null;
     meta?: JSONAPI$BaseObject;
     links?: JSONAPI$ResourceLinksObject;
 }

package/dist/types/packages/router/route/params/errors/client-generated-id-error.d.ts

@@ -0,0 +1,13 @@
+import type { Server$ErrorSource } from '../../../../server';
+/**
+ * JSON:API 1.0: "A server MUST return 403 Forbidden in response to an
+ * unsupported request to create a resource with a client-generated ID."
+ *
+ * @private
+ */
+declare class ClientGeneratedIdError extends TypeError {
+    source: Server$ErrorSource;
+    constructor();
+}
+declare const _default: new (...args: Array<any>) => ClientGeneratedIdError & import("../../../../server/interfaces").Server$Error;
+export default _default;

package/dist/types/packages/router/route/params/errors/forbidden-parameter-error.d.ts

@@ -0,0 +1,14 @@
+import type { Server$ErrorSource } from '../../../../server';
+/**
+ * JSON:API 1.0: "A server MUST return 403 Forbidden in response to an
+ * unsupported request to update a resource or relationship." Used for members
+ * the model knows about but the controller does not accept (`params`).
+ *
+ * @private
+ */
+declare class ForbiddenParameterError extends TypeError {
+    source: Server$ErrorSource;
+    constructor(path: string);
+}
+declare const _default: new (...args: Array<any>) => ForbiddenParameterError & import("../../../../server/interfaces").Server$Error;
+export default _default;

package/dist/types/packages/router/route/params/errors/index.d.ts

@@ -3,3 +3,5 @@ export { default as ParameterValueError } from './parameter-value-error';
 export { default as InvalidParameterError } from './invalid-parameter-error';
 export { default as ResourceMismatchError } from './resource-mismatch-error';
 export { default as ParameterRequiredError } from './parameter-required-error';
+export { default as ClientGeneratedIdError } from './client-generated-id-error';
+export { default as ForbiddenParameterError } from './forbidden-parameter-error';

package/dist/types/packages/router/route/params/errors/invalid-parameter-error.d.ts

@@ -1,7 +1,9 @@
+import type { Server$ErrorSource } from '../../../../server';
 /**
  * @private
  */
 declare class InvalidParameterError extends TypeError {
+    source: Server$ErrorSource;
     constructor(path: string);
 }
 declare const _default: new (...args: Array<any>) => InvalidParameterError & import("../../../../server/interfaces").Server$Error;

package/dist/types/packages/router/route/params/errors/parameter-not-nullable-error.d.ts

@@ -1,8 +1,10 @@
+import type { Server$ErrorSource } from '../../../../server';
 import type { ParameterLike } from '../index';
 /**
  * @private
  */
 declare class ParameterNotNullableError extends TypeError {
+    source: Server$ErrorSource;
     constructor({ path }: ParameterLike);
 }
 declare const _default: new (...args: Array<any>) => ParameterNotNullableError & import("../../../../server/interfaces").Server$Error;

package/dist/types/packages/router/route/params/errors/parameter-required-error.d.ts

@@ -1,7 +1,9 @@
+import type { Server$ErrorSource } from '../../../../server';
 /**
  * @private
  */
 declare class ParameterRequiredError extends TypeError {
+    source: Server$ErrorSource;
     constructor(path: string);
 }
 declare const _default: new (...args: Array<any>) => ParameterRequiredError & import("../../../../server/interfaces").Server$Error;

package/dist/types/packages/router/route/params/errors/parameter-type-error.d.ts

@@ -1,8 +1,10 @@
+import type { Server$ErrorSource } from '../../../../server';
 import type { ParameterLike } from '../index';
 /**
  * @private
  */
 declare class ParameterTypeError extends TypeError {
+    source: Server$ErrorSource;
     constructor(param: ParameterLike, actual: string);
 }
 declare const _default: new (...args: Array<any>) => ParameterTypeError & import("../../../../server/interfaces").Server$Error;

package/dist/types/packages/router/route/params/errors/parameter-value-error.d.ts

@@ -1,8 +1,10 @@
+import type { Server$ErrorSource } from '../../../../server';
 import type { ParameterLike } from '../index';
 /**
  * @private
  */
 declare class ParameterValueError extends TypeError {
+    source: Server$ErrorSource;
     constructor(param: ParameterLike, actual: unknown);
 }
 declare const _default: new (...args: Array<any>) => ParameterValueError & import("../../../../server/interfaces").Server$Error;

package/dist/types/packages/router/route/params/errors/resource-mismatch-error.d.ts

@@ -1,7 +1,9 @@
+import type { Server$ErrorSource } from '../../../../server';
 /**
  * @private
  */
 declare class ResourceMismatchError extends TypeError {
+    source: Server$ErrorSource;
     constructor(path: string, expected: unknown, actual: unknown);
 }
 declare const _default: new (...args: Array<any>) => ResourceMismatchError & import("../../../../server/interfaces").Server$Error;

package/dist/types/packages/router/route/params/index.d.ts

@@ -12,6 +12,7 @@ export declare function defaultParamsFor({ type, controller }: {
     type: string;
     controller: Controller;
 }): Record<string, unknown>;
+export { default as validateClientId } from './utils/validate-client-id';
 export { default as validateResourceId } from './utils/validate-resource-id';
 export type { ParameterLike, ParameterLike$opts } from './interfaces';
 export type { default as Parameter } from './parameter';

package/dist/types/packages/router/route/params/parameter/forbidden-parameter.d.ts

@@ -0,0 +1,12 @@
+import Parameter from './index';
+/**
+ * A member the resource has but the controller does not accept. Any value for
+ * it is rejected with 403 rather than the 400 an unknown member gets.
+ *
+ * @private
+ */
+declare class ForbiddenParameter extends Parameter {
+    constructor(path: string);
+    validate<V>(): V;
+}
+export default ForbiddenParameter;

package/dist/types/packages/router/route/params/parameter/index.d.ts

@@ -8,6 +8,14 @@ declare class Parameter extends FreezeableSet<unknown> {
     type: string;
     required: boolean;
     sanitize: boolean;
+    /**
+     * Whether the parameter only accepts the given `values`. A parameter built
+     * without `values` accepts any value of its type; one built with `values`
+     * accepts only those — so an empty list accepts nothing. (Both used to look
+     * alike as an empty set, which let e.g. `?include=anything` through on a
+     * serializer without relationships, where JSON:API requires a 400.)
+     */
+    restricted: boolean;
     constructor({ path, type, values, required, sanitize }: Parameter$opts);
     validate<V>(value: V): V;
 }

package/dist/types/packages/router/route/params/utils/validate-client-id.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Reject `data.id` on a create request before the parameter tree runs, so it
+ * is answered with 403 (unsupported client-generated ID) rather than the 400
+ * an unknown member gets.
+ *
+ * @private
+ */
+export default function validateClientId(params: Record<string, unknown>): boolean;

package/dist/types/packages/serializer/index.d.ts

@@ -1,6 +1,9 @@
+import type { Bundle$Namespace } from '../loader';
 import type { Model, ModelClass } from '../database';
 import type { JSONAPI$Document, JSONAPI$DocumentLinks, JSONAPI$ResourceObject, JSONAPI$RelationshipObject } from '../jsonapi';
 import type { Serializer$opts } from './interfaces';
+import type { Linkage } from './utils/load-linkage';
+import type { IncludeTree } from './utils/include-tree';
 /**
  * ## Overview
  *
@@ -155,6 +158,17 @@ import type { Serializer$opts } from './interfaces';
  * If we request that the `posts` association is included from the `/users`
  * endpoint, we will only get the `attributes` that the `PostsSerializer` has
  * defined even though the response is processed by the `UsersSerializer`.
+ * The same goes for relationships: each included resource carries the
+ * `relationships` its own Serializer declares in `hasOne` and `hasMany`.
+ *
+ * Included resources follow the request's namespace: from `/admin/posts`,
+ * included comments are serialized by `AdminCommentsSerializer` when it
+ * exists and by `CommentsSerializer` otherwise (the same fallback a
+ * namespaced Controller uses), and their links point into `/admin`.
+ *
+ * Relationship paths may be nested, e.g. `/posts?include=comments.user`, up
+ * to the controller's `maxIncludeDepth` (3 by default). The intermediate
+ * resources (the comments) are included along with the leaves (their users).
  *
  * #### Sparse Fieldsets
  *
@@ -401,6 +415,17 @@ declare class Serializer<T extends Model> {
      * @private
      */
     namespace: string;
+    /**
+     * Every Serializer of the application, keyed by namespaced path (`posts`,
+     * `admin/posts`). Attached once all of them are built, and used by
+     * `serializerFor()` to serialize related resources in this Serializer's
+     * namespace.
+     *
+     * @property serializers
+     * @type {Map}
+     * @private
+     */
+    serializers?: Bundle$Namespace<Serializer<Model>>;
     constructor({ model, parent, namespace }: Serializer$opts<T>);
     /**
      * Transform an array of Model instances or a single Model instance into a
@@ -423,25 +448,40 @@ declare class Serializer<T extends Model> {
      * the resource and relationship objects in the returned [JSON API](
      * http://jsonapi.org) document object.
      *
-     * @param {Array} options.include - An array of strings containing the
-     * relationship keys that should be added to the top level included object of
-     * the returned [JSON API](http://jsonapi.org) document object.
+     * @param {Array} options.include - An array of relationship paths (e.g.
+     * `'comments'` or `'comments.user'`) whose resources should be added to the
+     * top level included object of the returned [JSON API](http://jsonapi.org)
+     * document object. Intermediate resources of a nested path are included too.
+     *
+     * @param {String} options.namespace - The namespace of the request, i.e. of
+     * the Controller handling it. Every link in the document is built in it, and
+     * included resources are serialized by their Serializer in it (falling back
+     * to the root). Defaults to this Serializer's namespace — which is the root
+     * one when a namespaced Controller has no Serializer of its own, so the
+     * Controller passes its namespace explicitly.
      *
      * @return {Promise} Resolves with a [JSON API](http://jsonapi.org) document
      * object.
      *
      * @private
      */
-    format({ data, links, domain, include }: {
+    format({ data, links, domain, include, namespace }: {
         data: T | Array<T>;
         links: JSONAPI$DocumentLinks;
         domain: string;
         include: Array<string>;
+        namespace?: string;
     }): Promise<JSONAPI$Document>;
     /**
      * Transform a single Model instance into a [JSON API](http://jsonapi.org)
      * resource object.
      *
+     * Relationships are serialized in one of two ways. By default each one is
+     * read from the Model instance (for primary data the query has already
+     * loaded them). When `linkage` is given — as it is for included resources,
+     * whose relationships are batch-loaded by `addIncluded()` — the resource
+     * linkage is built from it instead, without touching the database.
+     *
      * @method formatOne
      *
      * @param {Object} options - An options object used for building the returned
@@ -458,30 +498,33 @@ declare class Serializer<T extends Model> {
      * the top level links object or relationship links objects in the returned
      * [JSON API](http://jsonapi.org) resource object.
      *
-     * @param {Array} options.include - An array of strings containing the
-     * relationship keys that should be added to the top level included object of
-     * a [JSON API](http://jsonapi.org) document object.
+     * @param {Array} options.include - An array of the relationship keys whose
+     * related records should be collected into `options.related`.
      *
-     * @param {Array} options.included - An array of [JSON API](
-     * http://jsonapi.org) resource objects that will be added to the top level
-     * included array of a [JSON API](http://jsonapi.org) document object.
+     * @param {Map} options.related - Collects, per relationship key in
+     * `options.include`, the related Model instances that belong in the top
+     * level included object of a [JSON API](http://jsonapi.org) document object.
      *
-     * @param {Boolean} options.formatRelationships - Wether or not
-     * relationships should be formatted and included in the returned
-     * [JSON API](http://jsonapi.org) resource object.
+     * @param {Object} options.linkage - Pre-loaded resource linkage (related
+     * primary keys per relationship key) to serialize relationships from.
+     *
+     * @param {String} options.namespace - The namespace to build links in.
+     * Defaults to this Serializer's; included resources pass the namespace of
+     * the request, so every link in a document points into the same namespace.
      *
      * @return {Promise} Resolves with a [JSON API](http://jsonapi.org) resource
      * object.
      *
      * @private
      */
-    formatOne({ item, links, domain, include, included, formatRelationships }: {
+    formatOne({ item, links, domain, include, related, linkage, namespace }: {
         item: T;
         links?: boolean;
         domain: string;
-        include: Array<string>;
-        included: Array<JSONAPI$ResourceObject>;
-        formatRelationships?: boolean;
+        include?: Array<string>;
+        related?: Map<string, Array<Model>>;
+        linkage?: Linkage;
+        namespace?: string;
     }): Promise<JSONAPI$ResourceObject>;
     /**
      * Transform a single Model instance into a [JSON API](http://jsonapi.org)
@@ -489,33 +532,65 @@ declare class Serializer<T extends Model> {
      *
      * @method formatRelationship
      *
-     * @param {Object} options - An options object used for building the returned
+     * @param {Model} item - The Model instance to transform into the returned
      * [JSON API](http://jsonapi.org) relationship object.
      *
-     * @param {Model} options.item - The Model instance to transform into the
+     * @param {String} domain - A string used to build links included in the
      * returned [JSON API](http://jsonapi.org) relationship object.
      *
-     * @param {String} options.domain - A string used to build links included in
-     * the returned [JSON API](http://jsonapi.org) relationship object.
-     *
-     * @param {Array} options.include - An array of strings containing the
-     * relationship keys that should be added to the top level included object of
-     * a [JSON API](http://jsonapi.org) document object.
+     * @return {Object} A [JSON API](http://jsonapi.org) relationship object.
      *
-     * @param {Array} options.included - An array of [JSON API](
-     * http://jsonapi.org) resource objects that will be added to the top level
-     * included array of a [JSON API](http://jsonapi.org) document object.
-     *
-     * @return {Promise} Resolves with a [JSON API](http://jsonapi.org)
-     * relationship object.
+     * @private
+     */
+    formatRelationship(item: Model, domain: string, namespace?: string): JSONAPI$RelationshipObject;
+    /**
+     * Build a [JSON API](http://jsonapi.org) relationship object from resource
+     * linkage, in the same shape `formatRelationship()` produces from Model
+     * instances: to-one relationships carry a `links` object, to-many ones only
+     * `data`, and a missing to-one relationship is `{ data: null }`.
      *
+     * @method formatLinkage
+     * @private
+     */
+    formatLinkage(domain: string, type: string | undefined, linkage: Array<string> | string | null | undefined, namespace?: string): JSONAPI$RelationshipObject;
+    /**
+     * Add `records` (instances of `model`) to `included` as resource objects,
+     * then recurse into the relationships named in `tree`. Each is serialized by
+     * `model`'s Serializer in this Serializer's namespace (`serializerFor()`), so
+     * `/admin/posts?include=comments` uses `AdminCommentsSerializer` when there
+     * is one and `CommentsSerializer` otherwise. The relationships of every level
+     * are batch-loaded with one query per relationship, not one per record.
+     *
+     * @method addIncluded
      * @private
      */
-    formatRelationship({ item, domain, include, included }: {
-        item: Model;
+    addIncluded({ model, records, tree, domain, included, namespace }: {
+        model: ModelClass;
+        records: Array<Model>;
+        tree: IncludeTree;
         domain: string;
-        include: boolean;
-        included: Array<JSONAPI$ResourceObject>;
-    }): Promise<JSONAPI$RelationshipObject>;
+        included: Map<string, JSONAPI$ResourceObject>;
+        namespace: string;
+    }): Promise<void>;
+    /**
+     * Resolve the Serializer for `model` in `namespace` (this Serializer's by
+     * default), the way a namespaced Controller resolves its own:
+     * `admin/comments` if it exists, otherwise the closest ancestor namespace's,
+     * down to the root `comments` Serializer. Falls back to `model.serializer`
+     * when this Serializer was not created by an application (e.g. in
+     * isolation).
+     *
+     * Pass the request's namespace when there is one: a Serializer's own
+     * namespace is the root one whenever it is a namespaced Controller's
+     * fallback.
+     *
+     * @method serializerFor
+     * @private
+     */
+    serializerFor(model: ModelClass, namespace?: string): Serializer<Model>;
+    /**
+     * @private
+     */
+    linkFor(domain: string, type: string, id: string, namespace?: string): string;
 }
 export default Serializer;