@edium/halifax 1.0.0 → 2.0.0

package/dist/core/types.d.ts

@@ -58,16 +58,13 @@ export interface HttpServer {
 }
 /** Flags indicating which optional repository operations the adapter supports. */
 export interface RepositoryCapabilities {
-    /** True when the adapter can execute raw SQL via the query builder. */
-    supportsNativeSql: boolean;
-    /** True when the adapter supports `?include=` for eager-loading relations. */
+    /**
+     * True when the adapter can eager-load relations via `?include=`. When `false`, the router
+     * rejects any `?include=` request with 422 instead of silently ignoring it.
+     */
     supportsIncludes: boolean;
-    /** True when the adapter can participate in database transactions. */
-    supportsTransactions: boolean;
     /** True when `createMany` returns the created records rather than an empty array. */
     supportsCreateManyReturn: boolean;
-    /** True when the adapter accepts a NoSQL-style query AST (non-SQL ORMs). */
-    supportsNoSqlQueryAst: boolean;
 }
 /** Options for paginated, filtered, and sorted list queries. */
 export interface ListOptions {
@@ -106,8 +103,8 @@ export interface UpdateManyResult<TRecord> {
     /** Updated records, when the adapter supports returning them. */
     results?: TRecord[];
 }
-/** Result envelope returned by `executeQueryBuilder`. */
-export interface NativeQueryResult<TRecord> {
+/** Result envelope returned by `executeQuery`. */
+export interface QueryResult<TRecord> {
     /** Total number of matching records (before pagination). */
     count?: number;
     /** Records for the current page. */
@@ -118,10 +115,32 @@ export interface CreateOptions {
     /** An idempotency key — the adapter may de-duplicate requests with the same key. */
     idempotencyKey?: string;
 }
+/**
+ * A resolved tenant constraint for a single request: the column to scope on and
+ * the value the current caller is allowed to see. Produced by the router from
+ * {@link TenantResourceConfig} (the field) and the tenant resolver (the value),
+ * then handed to {@link Repository.withScope}.
+ */
+export interface TenantScope {
+    /** Column / property on the model that stores the tenant key (e.g. `'companyId'`). */
+    field: string;
+    /** The tenant key the caller is bound to (e.g. their company id). */
+    value: unknown;
+}
 /** Core data-access contract that every Halifax repository adapter must satisfy. */
 export interface Repository<TRecord = unknown, TCreate = Partial<TRecord>, TUpdate = Partial<TRecord>> {
     /** Optional capability flags used by Halifax to decide which routes to activate. */
     readonly capabilities?: Partial<RepositoryCapabilities>;
+    /**
+     * Field schema the adapter knows about (e.g. derived from a Prisma model). When present,
+     * a {@link ResourceDefinition} may omit `fields` entirely (these are used as the base) or
+     * supply a sparse subset that is merged over these as per-field overrides.
+     */
+    readonly fields?: FieldDefinition[];
+    /** Relation schema the adapter knows about — used as the base for `?include=` access. */
+    readonly relations?: RelationDefinition[];
+    /** Primary-key field name (default `'id'`). The router protects this field from write bodies. */
+    readonly idField?: string;
     /**
      * Fetch a single record by its primary key.
      * @param id - Primary key value (integer or UUID string).
@@ -187,7 +206,21 @@ export interface Repository<TRecord = unknown, TCreate = Partial<TRecord>, TUpda
      * @param query - Full query AST including table name, filters, pagination, and sort.
      * @returns A count-and-results envelope for the matching rows.
      */
-    executeQueryBuilder?(query: IQueryOptions): Promise<NativeQueryResult<TRecord>>;
+    executeQuery?(query: IQueryOptions): Promise<QueryResult<TRecord>>;
+    /**
+     * Return a request-scoped clone of this repository that transparently constrains
+     * **every** operation to the given {@link TenantScope}. Reads are filtered by the
+     * scope, writes are stamped with it, and bulk SQL operations have the scope AND-ed
+     * into their WHERE clause so callers can never reach another tenant's rows.
+     *
+     * Adapters that cannot enforce scoping safely should leave this undefined — the
+     * router treats a tenant-scoped resource whose repository lacks `withScope` as a
+     * fatal misconfiguration (fail-closed) rather than serving it unscoped.
+     *
+     * @param scope - The resolved tenant constraint for the current request.
+     * @returns A new repository instance bound to `scope` (the original is unchanged).
+     */
+    withScope?(scope: TenantScope): Repository<TRecord, TCreate, TUpdate>;
 }
 /** All CRUD action identifiers used for permissions and audit. */
 export type CrudAction = 'create' | 'readOne' | 'readMany' | 'readManyWithQueryBuilder' | 'updateOne' | 'updateMany' | 'upsertOne' | 'deleteOne' | 'deleteMany';
@@ -228,10 +261,14 @@ export interface ModelSchema {
 export interface ModelResourceOptions {
     /** When true, this model is skipped entirely. */
     exclude?: boolean;
+    /**
+     * Tenant isolation for this model. Set `{ field }` to scope on a specific column,
+     * or `false` to opt this model out of an otherwise tenant-scoped API. When omitted,
+     * the model is auto-scoped if the API's default tenant field exists on it.
+     */
+    tenant?: TenantResourceConfig | false;
     /** Override the URL prefix (default: auto-derived kebab-plural of the model name). */
     routePrefix?: string;
-    /** Override the database table name. */
-    tableName?: string;
     /** Override the default CRUD permissions for this model. */
     permissions?: CrudPermissions;
     /** Required permission strings per action for fine-grained access control. */
@@ -243,19 +280,35 @@ export interface ModelResourceOptions {
     /** Maximum nesting depth for WHERE clause children (default: 3). */
     maxFilterDepth?: number;
 }
-/** Describes a single column exposed through the Halifax API. */
+/**
+ * Describes a single column exposed through the Halifax API.
+ *
+ * Every flag is **permissive by default** — only set one to `false` to restrict a field.
+ * A field with just `{ name }` is filterable, sortable, selectable, and writable. The lone
+ * exception is the primary key, which is non-writable by default (it comes from the URL / DB);
+ * set `writable: true` on it explicitly if you really want clients to supply it.
+ */
 export interface FieldDefinition {
     /** Column / property name. */
     name: string;
-    /** When `false`, the field cannot be used in `?field=` filters. */
+    /** When `false`, the field cannot be used in `?field=` filters. Defaults to `true`. */
     filterable?: boolean;
-    /** When `false`, the field cannot be used in `?order=` sorts. */
+    /** When `false`, the field cannot be used in `?order=` sorts. Defaults to `true`. */
     sortable?: boolean;
-    /** When `false`, the field is excluded from `?fields=` projections. */
+    /** When `false`, the field is excluded from `?fields=` projections. Defaults to `true`. */
     selectable?: boolean;
-    /** When `false`, the field is stripped from POST/PATCH request bodies. */
+    /** When `false`, the field is stripped from POST/PATCH/PUT bodies. Defaults to `true` (except the primary key). */
     writable?: boolean;
 }
+/**
+ * Declares that a resource is tenant-scoped: every request is confined to rows whose
+ * {@link TenantResourceConfig.field} equals the tenant value resolved for the caller.
+ * Omit `tenant` (or set it to `false`) to expose a resource globally / unscoped.
+ */
+export interface TenantResourceConfig {
+    /** Column / property on this model that stores the tenant key (e.g. `'companyId'`). */
+    field: string;
+}
 /** Describes a relation that callers may eagerly load via `?include=`. */
 export interface RelationDefinition {
     /** Relation name as defined on the Prisma model. */
@@ -265,29 +318,86 @@ export interface RelationDefinition {
 }
 /** Full definition of a Halifax resource: its repository, field schema, routing, and permissions. */
 export interface ResourceDefinition<TRecord = unknown, TCreate = Partial<TRecord>, TUpdate = Partial<TRecord>> {
-    /** Human-readable resource name (usually the Prisma model name). */
-    name: string;
-    /** URL path segment (e.g. `'users'`, `'blog-posts'`). */
+    /**
+     * URL path segment (e.g. `'users'`, `'blog-posts'`). The only required field — it defines
+     * the resource's public route, which has no safe default.
+     */
     routePrefix: string;
-    /** Database table name used by the query builder. */
-    tableName?: string;
-    /** Scalar field definitions — controls filtering, sorting, selection, and write access. */
-    fields: FieldDefinition[];
-    /** Relation definitions — controls `?include=` access. */
-    relations?: RelationDefinition[];
-    /** CRUD operation toggles. Defaults to {@link defaultCrudPermissions}. */
-    permissions?: CrudPermissions;
     /** The data adapter that handles reads and writes for this resource. */
     repository: Repository<TRecord, TCreate, TUpdate>;
+    /**
+     * Human-readable resource name (used in error messages and the cache-key namespace).
+     * Optional — defaults to a title-cased form of {@link routePrefix} (`'blog-posts'` → `'Blog Posts'`).
+     */
+    name?: string;
+    /**
+     * Scalar field definitions — control filtering, sorting, selection, and write access.
+     *
+     * Optional when the {@link repository} exposes its own field schema (e.g. a `PrismaAdapter`
+     * built with a `model`, or anything from `createPrismaResources`): in that case the
+     * repository's fields are the base, and any entries here are merged over them **by name** as
+     * sparse overrides — so you list only the fields you want to change. When the repository
+     * exposes no schema, this is the authoritative allow-list and is required.
+     */
+    fields?: FieldDefinition[];
+    /**
+     * Relation definitions — control `?include=` access. Merged over the repository's relation
+     * schema by name when the repository exposes one; otherwise the authoritative list.
+     */
+    relations?: RelationDefinition[];
+    /**
+     * Tenant isolation for this resource. When set (and a tenant resolver is configured
+     * on the API), every read/write/bulk operation is constrained to the caller's tenant.
+     * Set to `false` to explicitly opt a resource out of an otherwise tenant-scoped API.
+     * When omitted, the resource is scoped only if the API's default tenant field exists
+     * on this model (auto-detection); otherwise it is treated as global.
+     */
+    tenant?: TenantResourceConfig | false;
+    /**
+     * CRUD operation toggles. Merged over {@link defaultCrudPermissions}, which enables every
+     * action — so you only list the actions you want to **disable** (e.g. `{ allowDeleteMany: false }`).
+     */
+    permissions?: CrudPermissions;
     /** Required permission strings per action (checked by the auth strategy). */
     requiredPermissions?: Partial<Record<CrudAction, string[]>>;
-    /** Default page size when the caller omits `?limit=`. No limit applied when `undefined`. */
+    /**
+     * Default page size when the caller omits `?limit=`. Defaults to {@link DEFAULT_PAGE_LIMIT}
+     * (5000). Set to `0` to apply no default limit (return all rows when `?limit=` is omitted).
+     */
     defaultLimit?: number;
-    /** Hard cap on page size. Requests over this are silently capped. No cap when `undefined`. */
+    /**
+     * Hard cap on page size; larger requests are silently capped (the response `count` still
+     * reflects the true total). Defaults to {@link MAX_PAGE_LIMIT} (5000). Set to `0` to remove
+     * the cap entirely — combine `defaultLimit: 0` and `maxLimit: 0` to disable pagination.
+     */
     maxLimit?: number;
     /** Maximum nesting depth for WHERE clause children. Defaults to 3. */
     maxFilterDepth?: number;
+    /**
+     * Read-through caching for this resource. When set, the router caches
+     * `getOne`/`getMany`/query reads and invalidates them on any write to this resource.
+     * Overrides the API-wide default. Omit to inherit the API default (if any); set to
+     * `false` to explicitly disable caching for this resource even when a default is configured.
+     */
+    cache?: ResourceCacheConfig | false;
+}
+/** Per-resource read-through cache configuration. */
+export interface ResourceCacheConfig {
+    /** Time-to-live for cached reads, in seconds. `0` means **never expire** (cache forever). */
+    ttlSeconds: number;
 }
+/**
+ * Default page size applied when a resource sets no `defaultLimit` and the caller omits
+ * `?limit=`. Chosen as a generous safety ceiling — large enough for typical "show everything"
+ * UIs, small enough to prevent a runaway full-table scan. `getMany` always returns the true
+ * total `count`, so a page is never a silent drop; a resource can set `defaultLimit: 0` to
+ * return all rows by default.
+ */
+export declare const DEFAULT_PAGE_LIMIT = 5000;
+/**
+ * Default hard cap on page size applied when a resource sets no `maxLimit`. A resource can set
+ * `maxLimit: 0` to remove the cap entirely (no pagination).
+ */
+export declare const MAX_PAGE_LIMIT = 5000;
 /** Default permissions applied to every resource — all CRUD operations enabled. */
 export declare const defaultCrudPermissions: Required<CrudPermissions>;
-//# sourceMappingURL=types.d.ts.map

package/dist/core/types.js

@@ -1,3 +1,16 @@
+/**
+ * Default page size applied when a resource sets no `defaultLimit` and the caller omits
+ * `?limit=`. Chosen as a generous safety ceiling — large enough for typical "show everything"
+ * UIs, small enough to prevent a runaway full-table scan. `getMany` always returns the true
+ * total `count`, so a page is never a silent drop; a resource can set `defaultLimit: 0` to
+ * return all rows by default.
+ */
+export const DEFAULT_PAGE_LIMIT = 5000;
+/**
+ * Default hard cap on page size applied when a resource sets no `maxLimit`. A resource can set
+ * `maxLimit: 0` to remove the cap entirely (no pagination).
+ */
+export const MAX_PAGE_LIMIT = 5000;
 /** Default permissions applied to every resource — all CRUD operations enabled. */
 export const defaultCrudPermissions = {
     allowCreate: true,
@@ -10,4 +23,3 @@ export const defaultCrudPermissions = {
     allowDeleteOne: true,
     allowDeleteMany: true
 };
-//# sourceMappingURL=types.js.map

package/dist/core/validation.d.ts

@@ -15,7 +15,15 @@ export declare function isValidInt32(value: string | number | null, min?: number
  */
 export declare function isValidUuid(value: string): boolean;
 /**
- * Asserts that `value` is a valid integer ID or UUID string.
+ * Returns `true` when `value` is a valid MongoDB ObjectId (24 hex chars).
+ * Lets MongoDB-backed resources accept their `_id` values through the same `:id` route
+ * validation that integer and UUID keys use.
+ * @param value - String to test.
+ * @returns `true` when `value` is a 24-character hex string.
+ */
+export declare function isValidObjectId(value: string): boolean;
+/**
+ * Asserts that `value` is a valid integer ID, UUID, or MongoDB ObjectId string.
  * Throws {@link BadRequestError} when validation fails.
  * @param value - Raw `:id` route parameter to validate.
  */
@@ -45,8 +53,9 @@ export declare function validateSelectableFields(resource: ResourceDefinition, f
  */
 export declare function validateSortableFields(resource: ResourceDefinition, fields: string[]): void;
 /**
- * Throws {@link UnprocessableEntityError} when any of `includes` reference non-includable relations.
- * @param resource - The resource definition whose relations are checked.
+ * Throws {@link UnprocessableEntityError} when any of `includes` reference non-includable
+ * relations, or when the resource's repository reports it cannot eager-load relations at all.
+ * @param resource - The resource definition whose relations and repository are checked.
  * @param includes - Relation names to validate.
  */
 export declare function validateIncludes(resource: ResourceDefinition, includes?: string[]): void;
@@ -72,4 +81,3 @@ export declare function validateWhere(resource: ResourceDefinition, where?: IQue
  * @param query - The query AST to validate.
  */
 export declare function validateAdvancedQuery(resource: ResourceDefinition, query: IQueryOptions): void;
-//# sourceMappingURL=validation.d.ts.map

package/dist/core/validation.js

@@ -26,19 +26,32 @@ export function isValidInt32(value, min = 1) {
 export function isValidUuid(value) {
     return uuidValidate(value);
 }
+/** Matches a MongoDB ObjectId: exactly 24 hexadecimal characters. */
+const objectIdPattern = /^[a-f\d]{24}$/i;
 /**
- * Asserts that `value` is a valid integer ID or UUID string.
+ * Returns `true` when `value` is a valid MongoDB ObjectId (24 hex chars).
+ * Lets MongoDB-backed resources accept their `_id` values through the same `:id` route
+ * validation that integer and UUID keys use.
+ * @param value - String to test.
+ * @returns `true` when `value` is a 24-character hex string.
+ */
+export function isValidObjectId(value) {
+    return objectIdPattern.test(value);
+}
+/**
+ * Asserts that `value` is a valid integer ID, UUID, or MongoDB ObjectId string.
  * Throws {@link BadRequestError} when validation fails.
  * @param value - Raw `:id` route parameter to validate.
  */
 export function validateId(value) {
+    const message = 'Id parameter must be an integer (1–2147483647), a valid UUID, or a 24-character ObjectId.';
     if (value === undefined) {
-        throw new BadRequestError('Id parameter must be an integer (1–2147483647) or a valid UUID.');
+        throw new BadRequestError(message);
     }
     const isInt = isValidInt32(value);
-    const isUuid = typeof value === 'string' && isValidUuid(value);
-    if (!isInt && !isUuid) {
-        throw new BadRequestError('Id parameter must be an integer (1–2147483647) or a valid UUID.');
+    const isStringId = typeof value === 'string' && (isValidUuid(value) || isValidObjectId(value));
+    if (!isInt && !isStringId) {
+        throw new BadRequestError(message);
     }
 }
 /**
@@ -47,7 +60,7 @@ export function validateId(value) {
  * @returns Array of field name strings.
  */
 export function getFieldNames(resource) {
-    return resource.fields.map((field) => {
+    return (resource.fields ?? []).map((field) => {
         return field.name;
     });
 }
@@ -72,7 +85,7 @@ export function validateFields(resource, fields = []) {
  */
 export function validateSelectableFields(resource, fields) {
     const nonSelectable = fields.filter((name) => {
-        const field = resource.fields.find((f) => f.name === name);
+        const field = resource.fields?.find((f) => f.name === name);
         return field?.selectable === false;
     });
     if (nonSelectable.length) {
@@ -86,7 +99,7 @@ export function validateSelectableFields(resource, fields) {
  */
 export function validateSortableFields(resource, fields) {
     const nonSortable = fields.filter((name) => {
-        const field = resource.fields.find((f) => f.name === name);
+        const field = resource.fields?.find((f) => f.name === name);
         return field?.sortable === false;
     });
     if (nonSortable.length) {
@@ -94,11 +107,15 @@ export function validateSortableFields(resource, fields) {
     }
 }
 /**
- * Throws {@link UnprocessableEntityError} when any of `includes` reference non-includable relations.
- * @param resource - The resource definition whose relations are checked.
+ * Throws {@link UnprocessableEntityError} when any of `includes` reference non-includable
+ * relations, or when the resource's repository reports it cannot eager-load relations at all.
+ * @param resource - The resource definition whose relations and repository are checked.
  * @param includes - Relation names to validate.
  */
 export function validateIncludes(resource, includes = []) {
+    if (includes.length && resource.repository?.capabilities?.supportsIncludes === false) {
+        throw new UnprocessableEntityError('This resource does not support relation includes.');
+    }
     const validIncludes = new Set((resource.relations ?? [])
         .filter((relation) => {
         return relation.includable !== false;
@@ -120,7 +137,7 @@ export function validateIncludes(resource, includes = []) {
  * @param query - The raw query-string object from the HTTP request.
  */
 export function validateQueryString(resource, query) {
-    const filterableFieldNames = resource.fields
+    const filterableFieldNames = (resource.fields ?? [])
         .filter((f) => f.filterable !== false)
         .map((f) => f.name);
     const allFieldNames = new Set(getFieldNames(resource));
@@ -152,7 +169,7 @@ export function validateQueryString(resource, query) {
  * @param depth - Current recursion depth (used for nesting-limit enforcement; start at `0`).
  */
 export function validateWhere(resource, where = [], depth = 0) {
-    const maxDepth = resource.maxFilterDepth ?? 3;
+    const maxDepth = resource.maxFilterDepth ?? 4;
     if (depth > maxDepth) {
         throw new UnprocessableEntityError(`Filter nesting exceeds the maximum allowed depth of ${maxDepth}.`);
     }
@@ -190,6 +207,10 @@ export function validateAdvancedQuery(resource, query) {
         validateFields(resource, query.fields);
         validateSelectableFields(resource, query.fields);
     }
+    if (query.distinct) {
+        validateFields(resource, query.distinct);
+        validateSelectableFields(resource, query.distinct);
+    }
     if (query.orderBy) {
         const validOrders = new Set(Object.values(SqlOrder));
         const sortFields = query.orderBy.map((s) => s.field);
@@ -203,4 +224,3 @@ export function validateAdvancedQuery(resource, query) {
     }
     validateWhere(resource, query.where);
 }
-//# sourceMappingURL=validation.js.map

package/dist/enums/SqlComparison.d.ts

@@ -1,6 +1,16 @@
-/** SQL comparison operators used in query-builder WHERE clauses. */
+/**
+ * Comparison operators accepted in query-builder WHERE clauses.
+ *
+ * The classic SQL operators (`=`, `LIKE`, `IN`, `BETWEEN`, …) are kept as-is. The string
+ * operators (`CONTAINS`, `STARTS WITH`, `ENDS WITH`) are portable extensions that both
+ * Prisma and Drizzle express natively on every dialect, so they behave identically
+ * regardless of the underlying database — unlike `LIKE`, whose case-sensitivity varies
+ * by engine collation.
+ */
 export declare enum SqlComparison {
     Between = "BETWEEN",
+    Contains = "CONTAINS",
+    EndsWith = "ENDS WITH",
     Equal = "=",
     GreaterThan = ">",
     GreaterThanOrEqual = ">=",
@@ -13,6 +23,6 @@ export declare enum SqlComparison {
     NotBetween = "NOT BETWEEN",
     NotEqual = "<>",
     NotIn = "NOT IN",
-    NotLike = "NOT LIKE"
+    NotLike = "NOT LIKE",
+    StartsWith = "STARTS WITH"
 }
-//# sourceMappingURL=SqlComparison.d.ts.map

package/dist/enums/SqlComparison.js

@@ -1,7 +1,17 @@
-/** SQL comparison operators used in query-builder WHERE clauses. */
+/**
+ * Comparison operators accepted in query-builder WHERE clauses.
+ *
+ * The classic SQL operators (`=`, `LIKE`, `IN`, `BETWEEN`, …) are kept as-is. The string
+ * operators (`CONTAINS`, `STARTS WITH`, `ENDS WITH`) are portable extensions that both
+ * Prisma and Drizzle express natively on every dialect, so they behave identically
+ * regardless of the underlying database — unlike `LIKE`, whose case-sensitivity varies
+ * by engine collation.
+ */
 export var SqlComparison;
 (function (SqlComparison) {
     SqlComparison["Between"] = "BETWEEN";
+    SqlComparison["Contains"] = "CONTAINS";
+    SqlComparison["EndsWith"] = "ENDS WITH";
     SqlComparison["Equal"] = "=";
     SqlComparison["GreaterThan"] = ">";
     SqlComparison["GreaterThanOrEqual"] = ">=";
@@ -15,5 +25,5 @@ export var SqlComparison;
     SqlComparison["NotEqual"] = "<>";
     SqlComparison["NotIn"] = "NOT IN";
     SqlComparison["NotLike"] = "NOT LIKE";
+    SqlComparison["StartsWith"] = "STARTS WITH";
 })(SqlComparison || (SqlComparison = {}));
-//# sourceMappingURL=SqlComparison.js.map

package/dist/enums/SqlOperator.d.ts

@@ -3,4 +3,3 @@ export declare enum SqlOperator {
     And = "AND",
     Or = "OR"
 }
-//# sourceMappingURL=SqlOperator.d.ts.map

package/dist/enums/SqlOperator.js

@@ -4,4 +4,3 @@ export var SqlOperator;
     SqlOperator["And"] = "AND";
     SqlOperator["Or"] = "OR";
 })(SqlOperator || (SqlOperator = {}));
-//# sourceMappingURL=SqlOperator.js.map

package/dist/enums/SqlOrder.d.ts

@@ -3,4 +3,3 @@ export declare enum SqlOrder {
     ASC = "ASC",
     DESC = "DESC"
 }
-//# sourceMappingURL=SqlOrder.d.ts.map

package/dist/enums/SqlOrder.js

@@ -4,4 +4,3 @@ export var SqlOrder;
     SqlOrder["ASC"] = "ASC";
     SqlOrder["DESC"] = "DESC";
 })(SqlOrder || (SqlOrder = {}));
-//# sourceMappingURL=SqlOrder.js.map

package/dist/errors/AuthenticationError.d.ts

@@ -7,4 +7,3 @@ export declare class AuthenticationError extends HttpError {
      */
     constructor(message?: string, details?: unknown);
 }
-//# sourceMappingURL=AuthenticationError.d.ts.map

package/dist/errors/AuthenticationError.js

@@ -10,4 +10,3 @@ export class AuthenticationError extends HttpError {
         this.name = 'AuthenticationError';
     }
 }
-//# sourceMappingURL=AuthenticationError.js.map

package/dist/errors/AuthorizationError.d.ts

@@ -7,4 +7,3 @@ export declare class AuthorizationError extends HttpError {
      */
     constructor(message?: string, details?: unknown);
 }
-//# sourceMappingURL=AuthorizationError.d.ts.map

package/dist/errors/AuthorizationError.js

@@ -10,4 +10,3 @@ export class AuthorizationError extends HttpError {
         this.name = 'AuthorizationError';
     }
 }
-//# sourceMappingURL=AuthorizationError.js.map

package/dist/errors/BadRequestError.d.ts

@@ -7,4 +7,3 @@ export declare class BadRequestError extends HttpError {
      */
     constructor(message?: string, details?: unknown);
 }
-//# sourceMappingURL=BadRequestError.d.ts.map

package/dist/errors/BadRequestError.js

@@ -10,4 +10,3 @@ export class BadRequestError extends HttpError {
         this.name = 'BadRequestError';
     }
 }
-//# sourceMappingURL=BadRequestError.js.map

package/dist/errors/HttpError.d.ts

@@ -9,4 +9,3 @@ export declare abstract class HttpError extends Error {
      */
     constructor(message: string, status: number, details?: unknown);
 }
-//# sourceMappingURL=HttpError.d.ts.map

package/dist/errors/HttpError.js

@@ -14,4 +14,3 @@ export class HttpError extends Error {
         this.details = details;
     }
 }
-//# sourceMappingURL=HttpError.js.map

package/dist/errors/MethodNotAllowedError.d.ts

@@ -7,4 +7,3 @@ export declare class MethodNotAllowedError extends HttpError {
      */
     constructor(message?: string, details?: unknown);
 }
-//# sourceMappingURL=MethodNotAllowedError.d.ts.map

package/dist/errors/MethodNotAllowedError.js

@@ -10,4 +10,3 @@ export class MethodNotAllowedError extends HttpError {
         this.name = 'MethodNotAllowedError';
     }
 }
-//# sourceMappingURL=MethodNotAllowedError.js.map

package/dist/errors/NotAcceptableError.d.ts

@@ -7,4 +7,3 @@ export declare class NotAcceptableError extends HttpError {
      */
     constructor(message?: string, details?: unknown);
 }
-//# sourceMappingURL=NotAcceptableError.d.ts.map

package/dist/errors/NotAcceptableError.js

@@ -10,4 +10,3 @@ export class NotAcceptableError extends HttpError {
         this.name = 'NotAcceptableError';
     }
 }
-//# sourceMappingURL=NotAcceptableError.js.map

package/dist/errors/NotFoundError.d.ts

@@ -7,4 +7,3 @@ export declare class NotFoundError extends HttpError {
      */
     constructor(message?: string, details?: unknown);
 }
-//# sourceMappingURL=NotFoundError.d.ts.map

package/dist/errors/NotFoundError.js

@@ -10,4 +10,3 @@ export class NotFoundError extends HttpError {
         this.name = 'NotFoundError';
     }
 }
-//# sourceMappingURL=NotFoundError.js.map

package/dist/errors/NotImplementedError.d.ts

@@ -7,4 +7,3 @@ export declare class NotImplementedError extends HttpError {
      */
     constructor(message?: string, details?: unknown);
 }
-//# sourceMappingURL=NotImplementedError.d.ts.map

package/dist/errors/NotImplementedError.js

@@ -10,4 +10,3 @@ export class NotImplementedError extends HttpError {
         this.name = 'NotImplementedError';
     }
 }
-//# sourceMappingURL=NotImplementedError.js.map

package/dist/errors/ServerError.d.ts

@@ -7,4 +7,3 @@ export declare class ServerError extends HttpError {
      */
     constructor(message?: string, details?: unknown);
 }
-//# sourceMappingURL=ServerError.d.ts.map

package/dist/errors/ServerError.js

@@ -10,4 +10,3 @@ export class ServerError extends HttpError {
         this.name = 'ServerError';
     }
 }
-//# sourceMappingURL=ServerError.js.map

package/dist/errors/UnprocessableEntityError.d.ts

@@ -7,4 +7,3 @@ export declare class UnprocessableEntityError extends HttpError {
      */
     constructor(message?: string, details?: unknown);
 }
-//# sourceMappingURL=UnprocessableEntityError.d.ts.map

package/dist/errors/UnprocessableEntityError.js

@@ -10,4 +10,3 @@ export class UnprocessableEntityError extends HttpError {
         this.name = 'UnprocessableEntityError';
     }
 }
-//# sourceMappingURL=UnprocessableEntityError.js.map

package/dist/errors/UnsupportedMediaTypeError.d.ts

@@ -7,4 +7,3 @@ export declare class UnsupportedMediaTypeError extends HttpError {
      */
     constructor(message?: string, details?: unknown);
 }
-//# sourceMappingURL=UnsupportedMediaTypeError.d.ts.map

package/dist/errors/UnsupportedMediaTypeError.js

@@ -10,4 +10,3 @@ export class UnsupportedMediaTypeError extends HttpError {
         this.name = 'UnsupportedMediaTypeError';
     }
 }
-//# sourceMappingURL=UnsupportedMediaTypeError.js.map