lumen-framework 3.1.1 → 4.0.0

package/dist/types/packages/database/utils/type-for-column.d.ts

@@ -1,5 +1,3 @@
-import type { Database$column } from '../interfaces';
-/**
- * @private
- */
-export default function typeForColumn(column: Database$column): string | undefined;
+import type { DatabaseColumn } from '../interfaces';
+/** @internal */
+export default function typeForColumn(column: DatabaseColumn): string | undefined;

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

@@ -0,0 +1,13 @@
+import type { ModelClass } from '../interfaces';
+/**
+ * Check every relationship of `models`, once all of them are initialized:
+ * its `inverse` must name a relationship on the related model that points
+ * back (or, for a join model, the many-to-many relationship through it), of
+ * a kind that pairs with it, and its foreign key must be a column where it
+ * is expected. A mistake used to surface only on the first write that set
+ * the relationship, as an unrelated-looking `500`. Throws listing every
+ * problem.
+ *
+ * @internal
+ */
+export default function validateRelationships(models: Iterable<ModelClass>): void;

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

@@ -1,16 +1,16 @@
-import type { Server$ErrorSource } from '../../../server';
+import type { ServerErrorSource } 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
+ * @internal
  */
 declare class ValidationError extends Error {
     key: string;
-    source: Server$ErrorSource;
+    source: ServerErrorSource;
     constructor(key: string);
 }
-declare const _default: new (...args: Array<any>) => ValidationError & import("../../../server/interfaces").Server$Error;
+declare const _default: new (...args: Array<any>) => ValidationError & import("../../../server").ServerError;
 export default _default;

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

@@ -1,12 +1,10 @@
-import type { Validation$opts } from './interfaces';
-/**
- * @private
- */
+import type { ValidationOptions } from './interfaces';
+/** @internal */
 declare class Validation<T> {
     key: string;
     value: T;
     validator: (value?: T) => boolean;
-    constructor(opts: Validation$opts<T>);
+    constructor(opts: ValidationOptions<T>);
     isValid(): boolean;
 }
 export default Validation;

package/dist/types/packages/database/validation/interfaces.d.ts

@@ -1,4 +1,4 @@
-export type Validation$opts<T> = {
+export type ValidationOptions<T> = {
     key: string;
     value: T;
     validator: (value?: T) => boolean;

package/dist/types/packages/freezeable/map/index.d.ts

@@ -1,6 +1,4 @@
-/**
- * @private
- */
+/** @internal */
 declare class FreezeableMap<K, V> extends Map<K, V> {
     set(key: K, value: V): this;
     clear(): void;

package/dist/types/packages/freezeable/set/index.d.ts

@@ -1,6 +1,4 @@
-/**
- * @private
- */
+/** @internal */
 declare class FreezeableSet<T> extends Set<T> {
     add(value: T): this;
     clear(): void;

package/dist/types/packages/freezeable/utils/freeze.d.ts

@@ -1,20 +1,10 @@
-/**
- * @private
- */
+/** @internal */
 export default function freeze<T extends object>(value: T): T;
-/**
- * @private
- */
+/** @internal */
 export declare function freezeArray<T>(target: T[]): readonly T[];
-/**
- * @private
- */
+/** @internal */
 export declare function freezeValue<T>(value: T): T;
-/**
- * @private
- */
+/** @internal */
 export declare function freezeProps<T extends object>(target: T, makePublic: boolean, ...props: string[]): T;
-/**
- * @private
- */
+/** @internal */
 export declare function deepFreezeProps<T extends object>(target: T, makePublic: boolean, ...props: string[]): T;

package/dist/types/packages/freezeable/utils/is-frozen.d.ts

@@ -1,4 +1,2 @@
-/**
- * @private
- */
+/** @internal */
 export default function isFrozen(value: unknown): boolean;

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

@@ -1,11 +1,11 @@
 import type { Stats } from 'fs';
 import Watcher from './watcher';
-import type { fs$readOpts, fs$writeOpts } from './interfaces';
+import type { ReadOptions, WriteOptions } from './interfaces';
 export { default as rmrf } from './utils/rmrf';
 export { default as exists } from './utils/exists';
 export { default as isJSFile } from './utils/is-js-file';
 export { default as parsePath } from './utils/parse-path';
-export type { fs$ParsedPath } from './interfaces';
+export type { ParsedPath } from './interfaces';
 /**
  * @private
  */
@@ -29,23 +29,23 @@ export declare function rmdir(path: string): Promise<void>;
 /**
  * @private
  */
-export declare function readdir(path: string, opts?: fs$readOpts): Promise<Array<string>>;
+export declare function readdir(path: string, opts?: ReadOptions): Promise<Array<string>>;
 /**
  * @private
  */
-export declare function readdirRec(path: string, opts?: fs$readOpts): Promise<Array<string>>;
+export declare function readdirRec(path: string, opts?: ReadOptions): Promise<Array<string>>;
 /**
  * @private
  */
-export declare function readFile(path: string, opts?: fs$readOpts): Promise<string | Buffer>;
+export declare function readFile(path: string, opts?: ReadOptions): Promise<string | Buffer>;
 /**
  * @private
  */
-export declare function writeFile(path: string, data: string | Buffer, opts?: fs$writeOpts): Promise<void>;
+export declare function writeFile(path: string, data: string | Buffer, opts?: WriteOptions): Promise<void>;
 /**
  * @private
  */
-export declare function appendFile(path: string, data: string | Buffer, opts?: fs$writeOpts): Promise<void>;
+export declare function appendFile(path: string, data: string | Buffer, opts?: WriteOptions): Promise<void>;
 /**
  * @private
  */

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

@@ -1,14 +1,14 @@
-export type fs$writeOpts = string | {
+export type WriteOptions = string | {
     mode?: number;
     flag?: string;
     encoding?: string | null;
 };
-export type fs$readOpts = string | {
+export type ReadOptions = string | {
     flag?: string;
     encoding?: string | null;
 };
-export type fs$PathRemover = (source: string) => string;
-export interface fs$ParsedPath {
+export type PathRemover = (source: string) => string;
+export interface ParsedPath {
     root: string;
     dir: string;
     base: string;

package/dist/types/packages/fs/utils/parse-path.d.ts

@@ -1,5 +1,5 @@
-import type { fs$ParsedPath } from '../index';
+import type { ParsedPath } from '../index';
 /**
  * @private
  */
-export default function resolvePath(cwd?: string, dir?: string, name?: string): fs$ParsedPath;
+export default function resolvePath(cwd?: string, dir?: string, name?: string): ParsedPath;

package/dist/types/packages/fs/watcher/interfaces.d.ts

@@ -1,3 +1,3 @@
 import type { FSWatcher } from 'fs';
 import type { Client } from 'fb-watchman';
-export type Watcher$Client = Client | FSWatcher;
+export type WatcherClient = Client | FSWatcher;

package/dist/types/packages/jsonapi/errors/invalid-content-type-error.d.ts

@@ -1,8 +1,6 @@
-/**
- * @private
- */
+/** @internal */
 declare class InvalidContentTypeError extends TypeError {
-    constructor(contentType?: string);
+    constructor(contentType?: string, accepted?: Array<string>);
 }
-declare const _default: new (...args: Array<any>) => InvalidContentTypeError & import("../../server/interfaces").Server$Error;
+declare const _default: new (...args: Array<any>) => InvalidContentTypeError & import("../../server").ServerError;
 export default _default;

package/dist/types/packages/jsonapi/errors/not-acceptable-error.d.ts

@@ -1,8 +1,6 @@
-/**
- * @private
- */
+/** @internal */
 declare class NotAcceptableError extends TypeError {
     constructor(accept: string);
 }
-declare const _default: new (...args: Array<any>) => NotAcceptableError & import("../../server/interfaces").Server$Error;
+declare const _default: new (...args: Array<any>) => NotAcceptableError & import("../../server").ServerError;
 export default _default;

package/dist/types/packages/jsonapi/errors/unsupported-media-type-error.d.ts

@@ -1,8 +1,6 @@
-/**
- * @private
- */
+/** @internal */
 declare class UnsupportedMediaTypeError extends TypeError {
     constructor(contentType: string);
 }
-declare const _default: new (...args: Array<any>) => UnsupportedMediaTypeError & import("../../server/interfaces").Server$Error;
+declare const _default: new (...args: Array<any>) => UnsupportedMediaTypeError & import("../../server").ServerError;
 export default _default;

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

@@ -4,4 +4,4 @@ export { default as isJSONAPI } from './utils/is-jsonapi';
 export { default as hasMediaTypeParams } from './utils/has-media-type-params';
 export { parseAccept, parseMediaType } from './utils/media-type';
 export type { MediaType } from './utils/media-type';
-export type { JSONAPI$versions, JSONAPI$Document, JSONAPI$ErrorObject, JSONAPI$DocumentLinks, JSONAPI$ResourceObject, JSONAPI$IdentifierObject, JSONAPI$RelationshipObject } from './interfaces';
+export type { JsonApiVersion, JsonApiDocument, JsonApiErrorObject, JsonApiDocumentLinks, JsonApiResourceObject, JsonApiIdentifierObject, JsonApiRelationshipObject, JsonApiRelationshipDocument } from './interfaces';

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

@@ -1,66 +1,77 @@
-type JSONAPI$value = string | number | boolean | JSONAPI$BaseObject | Array<JSONAPI$BaseObject> | null | undefined;
-interface JSONAPI$BaseObject {
-    [key: string]: JSONAPI$value;
-    meta?: JSONAPI$BaseObject;
+type JsonApiValue = string | number | boolean | JsonApiBaseObject | Array<JsonApiBaseObject> | null | undefined;
+interface JsonApiBaseObject {
+    [key: string]: JsonApiValue;
+    meta?: JsonApiBaseObject;
 }
-interface JSONAPI$LinkObject {
+interface JsonApiLinkObject {
     href: string;
-    meta?: JSONAPI$BaseObject;
+    meta?: JsonApiBaseObject;
 }
-type JSONAPI$Link = string | JSONAPI$LinkObject | null;
-interface JSONAPI$ResourceLinksObject {
-    self?: JSONAPI$Link;
-    related?: JSONAPI$Link;
+type JsonApiLink = string | JsonApiLinkObject | null;
+interface JsonApiResourceLinksObject {
+    self?: JsonApiLink;
+    related?: JsonApiLink;
 }
-export type JSONAPI$versions = '1.0';
-export interface JSONAPI$IdentifierObject {
+export type JsonApiVersion = '1.0';
+export interface JsonApiIdentifierObject {
     id: string;
     type: string;
-    meta?: JSONAPI$BaseObject;
+    meta?: JsonApiBaseObject;
 }
-export interface JSONAPI$ResourceObject {
+export interface JsonApiResourceObject {
     id: string;
     type: string;
-    links?: JSONAPI$ResourceLinksObject;
-    attributes?: JSONAPI$BaseObject;
+    links?: JsonApiResourceLinksObject;
+    attributes?: JsonApiBaseObject;
     relationships?: {
-        [key: string]: JSONAPI$RelationshipObject | null | undefined;
+        [key: string]: JsonApiRelationshipObject | null | undefined;
     };
 }
-export interface JSONAPI$RelationshipObject {
-    data: JSONAPI$IdentifierObject | Array<JSONAPI$IdentifierObject> | null;
-    meta?: JSONAPI$BaseObject;
-    links?: JSONAPI$ResourceLinksObject;
+export interface JsonApiRelationshipObject {
+    data?: JsonApiIdentifierObject | Array<JsonApiIdentifierObject> | null;
+    meta?: JsonApiBaseObject;
+    links?: JsonApiResourceLinksObject;
 }
-export interface JSONAPI$DocumentLinks extends JSONAPI$ResourceLinksObject {
-    first?: JSONAPI$Link;
-    last?: JSONAPI$Link;
-    prev?: JSONAPI$Link | null;
-    next?: JSONAPI$Link | null;
+export interface JsonApiDocumentLinks extends JsonApiResourceLinksObject {
+    first?: JsonApiLink;
+    last?: JsonApiLink;
+    prev?: JsonApiLink | null;
+    next?: JsonApiLink | null;
 }
-export interface JSONAPI$ErrorObject {
+export interface JsonApiErrorObject {
     id?: string;
     code?: string;
-    meta?: JSONAPI$BaseObject;
+    meta?: JsonApiBaseObject;
     title?: string;
     status?: string;
     detail?: string;
     links?: {
-        about: JSONAPI$Link;
+        about: JsonApiLink;
     };
     source?: {
         pointer?: string;
         parameter?: string;
     };
 }
-export interface JSONAPI$Document {
-    data?: Array<JSONAPI$ResourceObject> | JSONAPI$ResourceObject;
-    links?: JSONAPI$DocumentLinks;
-    errors?: Array<JSONAPI$ErrorObject>;
-    included?: Array<JSONAPI$ResourceObject>;
+export interface JsonApiDocument {
+    data?: Array<JsonApiResourceObject> | JsonApiResourceObject;
+    meta?: JsonApiBaseObject;
+    links?: JsonApiDocumentLinks;
+    errors?: Array<JsonApiErrorObject>;
+    included?: Array<JsonApiResourceObject>;
     jsonapi?: {
-        version: JSONAPI$versions;
-        meta?: JSONAPI$BaseObject;
+        version: JsonApiVersion;
+        meta?: JsonApiBaseObject;
+    };
+}
+/**
+ * The document a relationship endpoint responds with: the relationship's
+ * resource linkage as primary data.
+ */
+export interface JsonApiRelationshipDocument extends Omit<JsonApiRelationshipObject, 'links'> {
+    links: JsonApiResourceLinksObject;
+    jsonapi: {
+        version: JsonApiVersion;
     };
 }
 export {};

package/dist/types/packages/jsonapi/utils/has-media-type-params.d.ts

@@ -1,6 +1,6 @@
 /**
  * Whether a media type (e.g. a `Content-Type` value) carries parameters.
  *
- * @private
+ * @internal
  */
 export default function hasMediaTypeParams(value: string): boolean;

package/dist/types/packages/jsonapi/utils/is-jsonapi.d.ts

@@ -1,6 +1,6 @@
 /**
  * Whether a media type is the JSON:API media type, ignoring parameters.
  *
- * @private
+ * @internal
  */
 export default function isJSONAPI(value: string): boolean;

package/dist/types/packages/jsonapi/utils/media-type.d.ts

@@ -5,7 +5,7 @@ export type MediaType = {
 /**
  * Parse a single media type, e.g. a `Content-Type` header value.
  *
- * @private
+ * @internal
  */
 export declare function parseMediaType(value: string): MediaType;
 /**
@@ -14,6 +14,6 @@ export declare function parseMediaType(value: string): MediaType;
  * Per RFC 7231 §5.3.2 the `q` weight (and any accept-extension after it) is
  * not a media type parameter, so it is not reported in `params`.
  *
- * @private
+ * @internal
  */
 export declare function parseAccept(value: string): Array<MediaType>;

package/dist/types/packages/loader/builder/index.d.ts

@@ -1,6 +1,6 @@
-import type { Bundle$Namespace } from '../index';
-import type { Builder$Class, Builder$Construct } from './interfaces';
+import type { BundleNamespace } from '../index';
+import type { BuilderClass, BuilderConstruct } from './interfaces';
 /**
  * @private
  */
-export declare function build<T>(group: Bundle$Namespace<Builder$Class<T>>, construct: Builder$Construct<T>): Bundle$Namespace<T>;
+export declare function build<T>(group: BundleNamespace<BuilderClass<T>>, construct: BuilderConstruct<T>): BundleNamespace<T>;

package/dist/types/packages/loader/builder/interfaces.d.ts

@@ -1,10 +1,10 @@
-import type { Bundle$Namespace, Bundle$NamespaceGroup } from '../index';
-export type Builder$Class<T> = new (...args: Array<any>) => T;
-export type Builder$NamespaceMeta<T> = {
+import type { BundleNamespace, BundleNamespaceGroup } from '../index';
+export type BuilderClass<T> = new (...args: Array<any>) => T;
+export type NamespaceMeta<T> = {
     key: string;
-    value: Bundle$Namespace<Builder$Class<T>>;
+    value: BundleNamespace<BuilderClass<T>>;
     parent: T | null;
 };
-export type Builder$ParentBuilder<T> = (target: Bundle$NamespaceGroup<Builder$Class<T>>) => Array<Builder$NamespaceMeta<T>>;
-export type Builder$ChildrenBuilder<T> = (target: Array<Builder$NamespaceMeta<T>>) => Array<Array<[string, T]>>;
-export type Builder$Construct<T> = (key: string, value: Builder$Class<T>, parent?: T | null) => T;
+export type ParentBuilder<T> = (target: BundleNamespaceGroup<BuilderClass<T>>) => Array<NamespaceMeta<T>>;
+export type ChildrenBuilder<T> = (target: Array<NamespaceMeta<T>>) => Array<Array<[string, T]>>;
+export type BuilderConstruct<T> = (key: string, value: BuilderClass<T>, parent?: T | null) => T;

package/dist/types/packages/loader/builder/utils/create-children-builder.d.ts

@@ -1,2 +1,2 @@
-import type { Builder$Construct, Builder$ChildrenBuilder } from '../interfaces';
-export default function createChildrenBuilder<T>(construct: Builder$Construct<T>): Builder$ChildrenBuilder<T>;
+import type { BuilderConstruct, ChildrenBuilder } from '../interfaces';
+export default function createChildrenBuilder<T>(construct: BuilderConstruct<T>): ChildrenBuilder<T>;

package/dist/types/packages/loader/builder/utils/create-parent-builder.d.ts

@@ -1,2 +1,9 @@
-import type { Builder$Construct, Builder$ParentBuilder } from '../interfaces';
-export default function createParentBuilder<T>(construct: Builder$Construct<T>): Builder$ParentBuilder<T>;
+import type { BuilderConstruct, ParentBuilder } from '../interfaces';
+/**
+ * Build each namespace's `application` module and record it as the
+ * namespace's parent, constructed with its own parent namespace's. A
+ * namespace without an `application` module takes its closest ancestor's, so
+ * its modules still get what the ancestors' ApplicationControllers declare
+ * (hooks, settings).
+ */
+export default function createParentBuilder<T>(construct: BuilderConstruct<T>): ParentBuilder<T>;

package/dist/types/packages/loader/builder/utils/sort-by-namespace.d.ts

@@ -1,5 +1,5 @@
-import type { Bundle$Namespace } from '../../index';
+import type { BundleNamespace } from '../../index';
 /**
  * @private
  */
-export default function sortByNamespace<T>([a]: [string, Bundle$Namespace<T>], [b]: [string, Bundle$Namespace<T>]): number;
+export default function sortByNamespace<T>([a]: [string, BundleNamespace<T>], [b]: [string, BundleNamespace<T>]): number;

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

@@ -5,4 +5,4 @@ import type { Loader } from './interfaces';
 export declare function createLoader(path: string): Loader;
 export { build } from './builder';
 export { closestAncestor, closestChild } from './resolver';
-export type { Loader, Bundle$Namespace, Bundle$NamespaceGroup } from './interfaces';
+export type { Loader, BundleNamespace, BundleNamespaceGroup } from './interfaces';

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

@@ -1,4 +1,4 @@
 import type { FreezeableMap } from '../freezeable';
 export type Loader = (type: string) => any;
-export type Bundle$Namespace<T> = FreezeableMap<string, T>;
-export type Bundle$NamespaceGroup<T> = FreezeableMap<string, Bundle$Namespace<T>>;
+export type BundleNamespace<T> = FreezeableMap<string, T>;
+export type BundleNamespaceGroup<T> = FreezeableMap<string, BundleNamespace<T>>;

package/dist/types/packages/loader/resolver/index.d.ts

@@ -1,7 +1,7 @@
-import type { Bundle$Namespace, Bundle$NamespaceGroup } from '../index';
+import type { BundleNamespace, BundleNamespaceGroup } from '../index';
 /**
  * @private
  */
-export declare function resolve<T>(group: Bundle$Namespace<T>): Bundle$NamespaceGroup<T>;
+export declare function resolve<T>(group: BundleNamespace<T>): BundleNamespaceGroup<T>;
 export { default as closestAncestor } from './utils/closest-ancestor';
 export { default as closestChild } from './utils/closest-child';

package/dist/types/packages/loader/resolver/utils/closest-ancestor.d.ts

@@ -1,2 +1,2 @@
-import type { Bundle$Namespace } from '../../index';
-export default function closestAncestor<T>(source: Bundle$Namespace<T>, key: string): T | undefined;
+import type { BundleNamespace } from '../../index';
+export default function closestAncestor<T>(source: BundleNamespace<T>, key: string): T | undefined;

package/dist/types/packages/loader/resolver/utils/closest-child.d.ts

@@ -1,2 +1,2 @@
-import type { Bundle$Namespace } from '../../index';
-export default function closestChild<T>(source: Bundle$Namespace<T>, key: string): T | undefined;
+import type { BundleNamespace } from '../../index';
+export default function closestChild<T>(source: BundleNamespace<T>, key: string): T | undefined;

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

@@ -1,8 +1,8 @@
 import { FreezeableMap, FreezeableSet } from '../freezeable';
-import type { Logger$level, Logger$format } from './interfaces';
+import type { LogLevel, LogFormat } from './interfaces';
 export declare const DEBUG = "DEBUG";
 export declare const INFO = "INFO";
 export declare const WARN = "WARN";
 export declare const ERROR = "ERROR";
-export declare const FORMATS: FreezeableSet<Logger$format>;
-export declare const LEVELS: FreezeableMap<Logger$level, number>;
+export declare const FORMATS: FreezeableSet<LogFormat>;
+export declare const LEVELS: FreezeableMap<LogLevel, number>;

package/dist/types/packages/logger/errors/invalid-config-error.d.ts

@@ -0,0 +1,5 @@
+/** @internal */
+declare class InvalidConfigError extends Error {
+    constructor(key: string, value: unknown, allowed: Iterable<string>);
+}
+export default InvalidConfigError;