@directus/api 9.25.0

package/dist/exceptions/database/dialects/mysql.js

@@ -0,0 +1,144 @@
+import { ContainsNullValuesException } from '../contains-null-values.js';
+import { InvalidForeignKeyException } from '../invalid-foreign-key.js';
+import { NotNullViolationException } from '../not-null-violation.js';
+import { RecordNotUniqueException } from '../record-not-unique.js';
+import { ValueOutOfRangeException } from '../value-out-of-range.js';
+import { ValueTooLongException } from '../value-too-long.js';
+var MySQLErrorCodes;
+(function (MySQLErrorCodes) {
+    MySQLErrorCodes["UNIQUE_VIOLATION"] = "ER_DUP_ENTRY";
+    MySQLErrorCodes["NUMERIC_VALUE_OUT_OF_RANGE"] = "ER_WARN_DATA_OUT_OF_RANGE";
+    MySQLErrorCodes["ER_DATA_TOO_LONG"] = "ER_DATA_TOO_LONG";
+    MySQLErrorCodes["NOT_NULL_VIOLATION"] = "ER_BAD_NULL_ERROR";
+    MySQLErrorCodes["FOREIGN_KEY_VIOLATION"] = "ER_NO_REFERENCED_ROW_2";
+    MySQLErrorCodes["ER_INVALID_USE_OF_NULL"] = "ER_INVALID_USE_OF_NULL";
+    MySQLErrorCodes["WARN_DATA_TRUNCATED"] = "WARN_DATA_TRUNCATED";
+})(MySQLErrorCodes || (MySQLErrorCodes = {}));
+export function extractError(error) {
+    switch (error.code) {
+        case MySQLErrorCodes.UNIQUE_VIOLATION:
+            return uniqueViolation(error);
+        case MySQLErrorCodes.NUMERIC_VALUE_OUT_OF_RANGE:
+            return numericValueOutOfRange(error);
+        case MySQLErrorCodes.ER_DATA_TOO_LONG:
+            return valueLimitViolation(error);
+        case MySQLErrorCodes.NOT_NULL_VIOLATION:
+            return notNullViolation(error);
+        case MySQLErrorCodes.FOREIGN_KEY_VIOLATION:
+            return foreignKeyViolation(error);
+        // Note: MariaDB throws data truncated for null value error
+        case MySQLErrorCodes.ER_INVALID_USE_OF_NULL:
+        case MySQLErrorCodes.WARN_DATA_TRUNCATED:
+            return containsNullValues(error);
+    }
+    return error;
+}
+function uniqueViolation(error) {
+    const betweenQuotes = /'([^']+)'/g;
+    const matches = error.sqlMessage.match(betweenQuotes);
+    if (!matches)
+        return error;
+    /**
+     * MySQL's error doesn't return the field name in the error. In case the field is created through
+     * Directus (/ Knex), the key name will be `<collection>_<field>_unique` in which case we can pull
+     * the field name from the key name
+     */
+    /** MySQL 8+ style error message */
+    if (matches[1].includes('.')) {
+        const collection = matches[1].slice(1, -1).split('.')[0];
+        let field = null;
+        const indexName = matches[1]?.slice(1, -1).split('.')[1];
+        if (indexName?.startsWith(`${collection}_`) && indexName.endsWith('_unique')) {
+            field = indexName?.slice(collection.length + 1, -7);
+        }
+        const invalid = matches[0]?.slice(1, -1);
+        return new RecordNotUniqueException(field, {
+            collection,
+            field,
+            invalid,
+        });
+    }
+    else {
+        /** MySQL 5.7 style error message */
+        const indexName = matches[1].slice(1, -1);
+        const collection = indexName.split('_')[0];
+        let field = null;
+        if (indexName?.startsWith(`${collection}_`) && indexName.endsWith('_unique')) {
+            field = indexName?.slice(collection.length + 1, -7);
+        }
+        const invalid = matches[0]?.slice(1, -1);
+        return new RecordNotUniqueException(field, {
+            collection,
+            field,
+            invalid,
+        });
+    }
+}
+function numericValueOutOfRange(error) {
+    const betweenTicks = /`([^`]+)`/g;
+    const betweenQuotes = /'([^']+)'/g;
+    const tickMatches = error.sql.match(betweenTicks);
+    const quoteMatches = error.sqlMessage.match(betweenQuotes);
+    if (!tickMatches || !quoteMatches)
+        return error;
+    const collection = tickMatches[0]?.slice(1, -1);
+    const field = quoteMatches[0]?.slice(1, -1);
+    return new ValueOutOfRangeException(field, {
+        collection,
+        field,
+    });
+}
+function valueLimitViolation(error) {
+    const betweenTicks = /`([^`]+)`/g;
+    const betweenQuotes = /'([^']+)'/g;
+    const tickMatches = error.sql.match(betweenTicks);
+    const quoteMatches = error.sqlMessage.match(betweenQuotes);
+    if (!tickMatches || !quoteMatches)
+        return error;
+    const collection = tickMatches[0]?.slice(1, -1);
+    const field = quoteMatches[0]?.slice(1, -1);
+    return new ValueTooLongException(field, {
+        collection,
+        field,
+    });
+}
+function notNullViolation(error) {
+    const betweenTicks = /`([^`]+)`/g;
+    const betweenQuotes = /'([^']+)'/g;
+    const tickMatches = error.sql.match(betweenTicks);
+    const quoteMatches = error.sqlMessage.match(betweenQuotes);
+    if (!tickMatches || !quoteMatches)
+        return error;
+    const collection = tickMatches[0]?.slice(1, -1);
+    const field = quoteMatches[0]?.slice(1, -1);
+    return new NotNullViolationException(field, {
+        collection,
+        field,
+    });
+}
+function foreignKeyViolation(error) {
+    const betweenTicks = /`([^`]+)`/g;
+    const betweenParens = /\(([^)]+)\)/g;
+    const tickMatches = error.sqlMessage.match(betweenTicks);
+    const parenMatches = error.sql.match(betweenParens);
+    if (!tickMatches || !parenMatches)
+        return error;
+    const collection = tickMatches[1].slice(1, -1);
+    const field = tickMatches[3].slice(1, -1);
+    const invalid = parenMatches[1].slice(1, -1);
+    return new InvalidForeignKeyException(field, {
+        collection,
+        field,
+        invalid,
+    });
+}
+function containsNullValues(error) {
+    const betweenTicks = /`([^`]+)`/g;
+    // Normally, we shouldn't read from the executed SQL. In this case, we're altering a single
+    // column, so we shouldn't have the problem where multiple columns are altered at the same time
+    const tickMatches = error.sql.match(betweenTicks);
+    if (!tickMatches)
+        return error;
+    const field = tickMatches[1].slice(1, -1);
+    return new ContainsNullValuesException(field);
+}

package/dist/exceptions/database/dialects/oracle.d.ts

@@ -0,0 +1,2 @@
+import type { OracleError } from './types.js';
+export declare function extractError(error: OracleError): OracleError | Error;

package/dist/exceptions/database/dialects/oracle.js

@@ -0,0 +1,23 @@
+import { ContainsNullValuesException } from '../contains-null-values.js';
+var OracleErrorCodes;
+(function (OracleErrorCodes) {
+    OracleErrorCodes[OracleErrorCodes["CONTAINS_NULL_VALUES"] = 2296] = "CONTAINS_NULL_VALUES";
+    // @TODO extend with other errors
+})(OracleErrorCodes || (OracleErrorCodes = {}));
+export function extractError(error) {
+    switch (error.errorNum) {
+        case OracleErrorCodes.CONTAINS_NULL_VALUES:
+            return containsNullValues(error);
+        default:
+            return error;
+    }
+}
+function containsNullValues(error) {
+    const betweenQuotes = /"([^"]+)"/g;
+    const matches = error.message.match(betweenQuotes);
+    if (!matches)
+        return error;
+    const collection = matches[0].slice(1, -1);
+    const field = matches[1].slice(1, -1);
+    return new ContainsNullValuesException(field, { collection, field });
+}

package/dist/exceptions/database/dialects/postgres.d.ts

@@ -0,0 +1,2 @@
+import type { PostgresError } from './types.js';
+export declare function extractError(error: PostgresError): PostgresError | Error;

package/dist/exceptions/database/dialects/postgres.js

@@ -0,0 +1,102 @@
+import { ContainsNullValuesException } from '../contains-null-values.js';
+import { InvalidForeignKeyException } from '../invalid-foreign-key.js';
+import { NotNullViolationException } from '../not-null-violation.js';
+import { RecordNotUniqueException } from '../record-not-unique.js';
+import { ValueOutOfRangeException } from '../value-out-of-range.js';
+import { ValueTooLongException } from '../value-too-long.js';
+var PostgresErrorCodes;
+(function (PostgresErrorCodes) {
+    PostgresErrorCodes["FOREIGN_KEY_VIOLATION"] = "23503";
+    PostgresErrorCodes["NOT_NULL_VIOLATION"] = "23502";
+    PostgresErrorCodes["NUMERIC_VALUE_OUT_OF_RANGE"] = "22003";
+    PostgresErrorCodes["UNIQUE_VIOLATION"] = "23505";
+    PostgresErrorCodes["VALUE_LIMIT_VIOLATION"] = "22001";
+})(PostgresErrorCodes || (PostgresErrorCodes = {}));
+export function extractError(error) {
+    switch (error.code) {
+        case PostgresErrorCodes.UNIQUE_VIOLATION:
+            return uniqueViolation(error);
+        case PostgresErrorCodes.NUMERIC_VALUE_OUT_OF_RANGE:
+            return numericValueOutOfRange(error);
+        case PostgresErrorCodes.VALUE_LIMIT_VIOLATION:
+            return valueLimitViolation(error);
+        case PostgresErrorCodes.NOT_NULL_VIOLATION:
+            return notNullViolation(error);
+        case PostgresErrorCodes.FOREIGN_KEY_VIOLATION:
+            return foreignKeyViolation(error);
+        default:
+            return error;
+    }
+}
+function uniqueViolation(error) {
+    const { table, detail } = error;
+    const betweenParens = /\(([^)]+)\)/g;
+    const matches = detail.match(betweenParens);
+    if (!matches)
+        return error;
+    const collection = table;
+    const field = matches[0].slice(1, -1);
+    const invalid = matches[1].slice(1, -1);
+    return new RecordNotUniqueException(field, {
+        collection,
+        field,
+        invalid,
+    });
+}
+function numericValueOutOfRange(error) {
+    const regex = /"(.*?)"/g;
+    const matches = error.message.match(regex);
+    if (!matches)
+        return error;
+    const collection = matches[0].slice(1, -1);
+    const field = null;
+    const invalid = matches[2].slice(1, -1);
+    return new ValueOutOfRangeException(field, {
+        collection,
+        field,
+        invalid,
+    });
+}
+function valueLimitViolation(error) {
+    /**
+     * NOTE:
+     * Postgres doesn't return the offending column
+     */
+    const regex = /"(.*?)"/g;
+    const matches = error.message.match(regex);
+    if (!matches)
+        return error;
+    const collection = matches[0].slice(1, -1);
+    const field = null;
+    return new ValueTooLongException(field, {
+        collection,
+        field,
+    });
+}
+function notNullViolation(error) {
+    const { table, column } = error;
+    if (!column)
+        return error;
+    if (error.message.endsWith('contains null values')) {
+        return new ContainsNullValuesException(column, { collection: table, field: column });
+    }
+    return new NotNullViolationException(column, {
+        collection: table,
+        field: column,
+    });
+}
+function foreignKeyViolation(error) {
+    const { table, detail } = error;
+    const betweenParens = /\(([^)]+)\)/g;
+    const matches = detail.match(betweenParens);
+    if (!matches)
+        return error;
+    const collection = table;
+    const field = matches[0].slice(1, -1);
+    const invalid = matches[1].slice(1, -1);
+    return new InvalidForeignKeyException(field, {
+        collection,
+        field,
+        invalid,
+    });
+}

package/dist/exceptions/database/dialects/sqlite.d.ts

@@ -0,0 +1,2 @@
+import type { SQLiteError } from './types.js';
+export declare function extractError(error: SQLiteError): SQLiteError | Error;

package/dist/exceptions/database/dialects/sqlite.js

@@ -0,0 +1,51 @@
+import { ContainsNullValuesException } from '../contains-null-values.js';
+import { InvalidForeignKeyException } from '../invalid-foreign-key.js';
+import { NotNullViolationException } from '../not-null-violation.js';
+import { RecordNotUniqueException } from '../record-not-unique.js';
+// NOTE:
+// - Sqlite doesn't have varchar with length support, so no ValueTooLongException
+// - Sqlite doesn't have a max range for numbers, so no ValueOutOfRangeException
+export function extractError(error) {
+    if (error.message.includes('SQLITE_CONSTRAINT: NOT NULL')) {
+        return notNullConstraint(error);
+    }
+    if (error.message.includes('SQLITE_CONSTRAINT: UNIQUE')) {
+        const errorParts = error.message.split(' ');
+        const [table, column] = errorParts[errorParts.length - 1].split('.');
+        if (!table || !column)
+            return error;
+        return new RecordNotUniqueException(column, {
+            collection: table,
+            field: column,
+        });
+    }
+    if (error.message.includes('SQLITE_CONSTRAINT: FOREIGN KEY')) {
+        /**
+         * NOTE:
+         * SQLite doesn't return any useful information in it's foreign key constraint failed error, so
+         * we can't extract the table/column/value accurately
+         */
+        return new InvalidForeignKeyException(null);
+    }
+    return error;
+}
+function notNullConstraint(error) {
+    const errorParts = error.message.split(' ');
+    const [table, column] = errorParts[errorParts.length - 1].split('.');
+    if (table && column) {
+        // Now this gets a little finicky... SQLite doesn't have any native ALTER, so Knex implements
+        // it by creating a new table, and then copying the data over. That also means we'll never get
+        // a ContainsNullValues constraint error, as there is no ALTER. HOWEVER, we can hack around
+        // that by checking for the collection name, as Knex's alter default template name will always
+        // start with _knex_temp. The best we can do in this case is check for that, and use it to
+        // decide between NotNullViolation and ContainsNullValues
+        if (table.startsWith('_knex_temp_alter')) {
+            return new ContainsNullValuesException(column);
+        }
+        return new NotNullViolationException(column, {
+            collection: table,
+            field: column,
+        });
+    }
+    return error;
+}

package/dist/exceptions/database/dialects/types.d.ts

@@ -0,0 +1,41 @@
+export type MSSQLError = {
+    message: string;
+    code: 'EREQUEST';
+    number: number;
+    state: number;
+    class: number;
+    serverName: string;
+    procName: string;
+    lineNumber: number;
+};
+export type MySQLError = {
+    message: string;
+    code: string;
+    errno: number;
+    sqlMessage: string;
+    sqlState: string;
+    index: number;
+    sql: string;
+};
+export type PostgresError = {
+    message: string;
+    length: number;
+    code: string;
+    detail: string;
+    schema: string;
+    table: string;
+    column?: string;
+    dataType?: string;
+    constraint?: string;
+};
+export type OracleError = {
+    message: string;
+    errorNum: number;
+    offset: number;
+};
+export type SQLiteError = {
+    message: string;
+    errno: number;
+    code: string;
+};
+export type SQLError = MSSQLError & MySQLError & PostgresError & SQLiteError & OracleError & Error;

package/dist/exceptions/database/dialects/types.js

@@ -0,0 +1 @@
+export {};

package/dist/exceptions/database/invalid-foreign-key.d.ts

@@ -0,0 +1,10 @@
+import { BaseException } from '@directus/exceptions';
+type Extensions = {
+    collection: string;
+    field: string;
+    invalid?: string;
+};
+export declare class InvalidForeignKeyException extends BaseException {
+    constructor(field: string | null, extensions?: Extensions);
+}
+export {};

package/dist/exceptions/database/invalid-foreign-key.js

@@ -0,0 +1,11 @@
+import { BaseException } from '@directus/exceptions';
+export class InvalidForeignKeyException extends BaseException {
+    constructor(field, extensions) {
+        if (field) {
+            super(`Invalid foreign key in field "${field}".`, 400, 'INVALID_FOREIGN_KEY', extensions);
+        }
+        else {
+            super(`Invalid foreign key.`, 400, 'INVALID_FOREIGN_KEY', extensions);
+        }
+    }
+}

package/dist/exceptions/database/not-null-violation.d.ts

@@ -0,0 +1,9 @@
+import { BaseException } from '@directus/exceptions';
+type Exceptions = {
+    collection: string;
+    field: string;
+};
+export declare class NotNullViolationException extends BaseException {
+    constructor(field: string, exceptions?: Exceptions);
+}
+export {};

package/dist/exceptions/database/not-null-violation.js

@@ -0,0 +1,6 @@
+import { BaseException } from '@directus/exceptions';
+export class NotNullViolationException extends BaseException {
+    constructor(field, exceptions) {
+        super(`Value for field "${field}" can't be null.`, 400, 'NOT_NULL_VIOLATION', exceptions);
+    }
+}

package/dist/exceptions/database/record-not-unique.d.ts

@@ -0,0 +1,10 @@
+import { BaseException } from '@directus/exceptions';
+type Extensions = {
+    collection: string;
+    field: string | null;
+    invalid?: string | undefined;
+};
+export declare class RecordNotUniqueException extends BaseException {
+    constructor(field: string | null, extensions?: Extensions);
+}
+export {};

package/dist/exceptions/database/record-not-unique.js

@@ -0,0 +1,11 @@
+import { BaseException } from '@directus/exceptions';
+export class RecordNotUniqueException extends BaseException {
+    constructor(field, extensions) {
+        if (field) {
+            super(`Field "${field}" has to be unique.`, 400, 'RECORD_NOT_UNIQUE', extensions);
+        }
+        else {
+            super(`Field has to be unique.`, 400, 'RECORD_NOT_UNIQUE', extensions);
+        }
+    }
+}

package/dist/exceptions/database/translate.d.ts

@@ -0,0 +1,11 @@
+import type { SQLError } from './dialects/types.js';
+/**
+ * Translates an error thrown by any of the databases into a pre-defined Exception. Currently
+ * supports:
+ * - Invalid Foreign Key
+ * - Not Null Violation
+ * - Record Not Unique
+ * - Value Out of Range
+ * - Value Too Long
+ */
+export declare function translateDatabaseError(error: SQLError): Promise<any>;

package/dist/exceptions/database/translate.js

@@ -0,0 +1,44 @@
+import getDatabase, { getDatabaseClient } from '../../database/index.js';
+import emitter from '../../emitter.js';
+import { extractError as mssql } from './dialects/mssql.js';
+import { extractError as mysql } from './dialects/mysql.js';
+import { extractError as oracle } from './dialects/oracle.js';
+import { extractError as postgres } from './dialects/postgres.js';
+import { extractError as sqlite } from './dialects/sqlite.js';
+/**
+ * Translates an error thrown by any of the databases into a pre-defined Exception. Currently
+ * supports:
+ * - Invalid Foreign Key
+ * - Not Null Violation
+ * - Record Not Unique
+ * - Value Out of Range
+ * - Value Too Long
+ */
+export async function translateDatabaseError(error) {
+    const client = getDatabaseClient();
+    let defaultError;
+    switch (client) {
+        case 'mysql':
+            defaultError = mysql(error);
+            break;
+        case 'cockroachdb':
+        case 'postgres':
+            defaultError = postgres(error);
+            break;
+        case 'sqlite':
+            defaultError = sqlite(error);
+            break;
+        case 'oracle':
+            defaultError = oracle(error);
+            break;
+        case 'mssql':
+            defaultError = await mssql(error);
+            break;
+    }
+    const hookError = await emitter.emitFilter('database.error', defaultError, { client }, {
+        database: getDatabase(),
+        schema: null,
+        accountability: null,
+    });
+    return hookError;
+}

package/dist/exceptions/database/value-out-of-range.d.ts

@@ -0,0 +1,10 @@
+import { BaseException } from '@directus/exceptions';
+type Exceptions = {
+    collection: string;
+    field: string | null;
+    invalid?: string;
+};
+export declare class ValueOutOfRangeException extends BaseException {
+    constructor(field: string | null, exceptions?: Exceptions);
+}
+export {};

package/dist/exceptions/database/value-out-of-range.js

@@ -0,0 +1,11 @@
+import { BaseException } from '@directus/exceptions';
+export class ValueOutOfRangeException extends BaseException {
+    constructor(field, exceptions) {
+        if (field) {
+            super(`Numeric value in field "${field ?? ''}" is out of range.`, 400, 'VALUE_OUT_OF_RANGE', exceptions);
+        }
+        else {
+            super(`Numeric value is out of range.`, 400, 'VALUE_OUT_OF_RANGE', exceptions);
+        }
+    }
+}

package/dist/exceptions/database/value-too-long.d.ts

@@ -0,0 +1,9 @@
+import { BaseException } from '@directus/exceptions';
+type Extensions = {
+    collection: string;
+    field: string | null;
+};
+export declare class ValueTooLongException extends BaseException {
+    constructor(field: string | null, extensions?: Extensions);
+}
+export {};

package/dist/exceptions/database/value-too-long.js

@@ -0,0 +1,11 @@
+import { BaseException } from '@directus/exceptions';
+export class ValueTooLongException extends BaseException {
+    constructor(field, extensions) {
+        if (field) {
+            super(`Value for field "${field}" is too long.`, 400, 'VALUE_TOO_LONG', extensions);
+        }
+        else {
+            super(`Value is too long.`, 400, 'VALUE_TOO_LONG', extensions);
+        }
+    }
+}

package/dist/exceptions/forbidden.d.ts

@@ -0,0 +1,6 @@
+import * as exceptions from '@directus/exceptions';
+declare const BaseException: typeof exceptions.BaseException;
+export declare class ForbiddenException extends BaseException {
+    constructor();
+}
+export {};

package/dist/exceptions/forbidden.js

@@ -0,0 +1,13 @@
+import * as exceptions from '@directus/exceptions';
+const { BaseException } = exceptions;
+export class ForbiddenException extends BaseException {
+    constructor() {
+        super(`You don't have permission to access this.`, 403, 'FORBIDDEN');
+        /**
+         * We currently don't show the reason for a forbidden exception in the API output, as that
+         * has the potential to leak schema information (eg a "No permission" vs "No permission to files"
+         * would leak that a thing called "files" exists.
+         * Ref https://github.com/directus/directus/discussions/4368
+         */
+    }
+}

package/dist/exceptions/graphql-validation.d.ts

@@ -0,0 +1,4 @@
+import * as sharedExceptions from '@directus/exceptions';
+export declare class GraphQLValidationException extends sharedExceptions.BaseException {
+    constructor(extensions: Record<string, any>);
+}

package/dist/exceptions/graphql-validation.js

@@ -0,0 +1,6 @@
+import * as sharedExceptions from '@directus/exceptions';
+export class GraphQLValidationException extends sharedExceptions.BaseException {
+    constructor(extensions) {
+        super('GraphQL validation error.', 400, 'GRAPHQL_VALIDATION_EXCEPTION', extensions);
+    }
+}

package/dist/exceptions/hit-rate-limit.d.ts

@@ -0,0 +1,9 @@
+import { BaseException } from '@directus/exceptions';
+type Extensions = {
+    limit: number;
+    reset: Date;
+};
+export declare class HitRateLimitException extends BaseException {
+    constructor(message: string, extensions: Extensions);
+}
+export {};

package/dist/exceptions/hit-rate-limit.js

@@ -0,0 +1,6 @@
+import { BaseException } from '@directus/exceptions';
+export class HitRateLimitException extends BaseException {
+    constructor(message, extensions) {
+        super(message, 429, 'REQUESTS_EXCEEDED', extensions);
+    }
+}

package/dist/exceptions/illegal-asset-transformation.d.ts

@@ -0,0 +1,4 @@
+import { BaseException } from '@directus/exceptions';
+export declare class IllegalAssetTransformation extends BaseException {
+    constructor(message: string);
+}

package/dist/exceptions/illegal-asset-transformation.js

@@ -0,0 +1,6 @@
+import { BaseException } from '@directus/exceptions';
+export class IllegalAssetTransformation extends BaseException {
+    constructor(message) {
+        super(message, 400, 'ILLEGAL_ASSET_TRANSFORMATION');
+    }
+}

package/dist/exceptions/index.d.ts

@@ -0,0 +1,21 @@
+export * from './forbidden.js';
+export * from './graphql-validation.js';
+export * from './hit-rate-limit.js';
+export * from './illegal-asset-transformation.js';
+export * from './invalid-config.js';
+export * from './invalid-credentials.js';
+export * from './invalid-ip.js';
+export * from './invalid-otp.js';
+export * from './invalid-payload.js';
+export * from './invalid-provider.js';
+export * from './invalid-query.js';
+export * from './invalid-token.js';
+export * from './method-not-allowed.js';
+export * from './range-not-satisfiable.js';
+export * from './route-not-found.js';
+export * from './service-unavailable.js';
+export * from './token-expired.js';
+export * from './unprocessable-entity.js';
+export * from './unsupported-media-type.js';
+export * from './user-suspended.js';
+export * from './unexpected-response.js';