@fastify-utils/error 0.0.0-stage → 1.0.1

package/out/index.mjs

@@ -0,0 +1,803 @@
+//#region src/core/http-error.ts
+var HttpError = class extends Error {
+	type;
+	title;
+	status;
+	detail;
+	instance;
+	constructor(params) {
+		super(params.detail, { cause: params.cause });
+		this.name = "HttpError";
+		this.type = params.type;
+		this.title = params.title;
+		this.status = params.status;
+		this.detail = params.detail;
+		this.instance = params.instance;
+		Error.captureStackTrace(this, this.constructor);
+	}
+	toJSON() {
+		return {
+			type: this.type,
+			title: this.title,
+			status: this.status,
+			detail: this.detail,
+			...this.instance && { instance: this.instance }
+		};
+	}
+};
+//#endregion
+//#region src/errors/server/bad-gateway-error.ts
+var BadGatewayError = class extends HttpError {
+	service;
+	constructor(detail, service) {
+		super({
+			type: getErrorType("bad-gateway"),
+			title: "Bad Gateway",
+			status: 502,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "BadGatewayError";
+		this.service = service;
+	}
+	toJSON() {
+		return {
+			...super.toJSON(),
+			...this.service && { service: this.service }
+		};
+	}
+};
+//#endregion
+//#region src/errors/server/factories.ts
+const standardFactories$1 = {
+	internal: (detail) => new InternalServerError(detail),
+	notImplemented: (detail) => new NotImplementedError(detail),
+	badGateway: (detail, service) => new BadGatewayError(detail, service),
+	serviceUnavailable: (detail, retryAfter) => new ServiceUnavailableError(detail, retryAfter),
+	gatewayTimeout: (detail, service) => new GatewayTimeoutError(detail, service),
+	httpVersionNotSupported: (detail) => new HttpVersionNotSupportedError(detail),
+	variantAlsoNegotiates: (detail) => new VariantAlsoNegotiatesError(detail),
+	insufficientStorage: (detail) => new InsufficientStorageError(detail),
+	loopDetected: (detail) => new LoopDetectedError(detail),
+	notExtended: (detail) => new NotExtendedError(detail),
+	networkAuthenticationRequired: (detail) => new NetworkAuthenticationRequiredError(detail)
+};
+const aliases$1 = {
+	db: (detail) => standardFactories$1.serviceUnavailable(detail),
+	fetch: (detail, service) => standardFactories$1.badGateway(detail, service),
+	envNotSet: (detail) => standardFactories$1.notImplemented(detail),
+	envInvalid: (detail) => standardFactories$1.notImplemented(detail),
+	maintenance: (detail, retryAfter) => standardFactories$1.serviceUnavailable(detail, retryAfter),
+	migration: (detail) => standardFactories$1.insufficientStorage(detail),
+	unhandledRejection: (detail) => standardFactories$1.internal(detail),
+	uncaughtException: (detail) => standardFactories$1.internal(detail)
+};
+const factories$1 = {
+	...standardFactories$1,
+	...aliases$1
+};
+//#endregion
+//#region src/errors/server/gateway-timeout-error.ts
+var GatewayTimeoutError = class extends HttpError {
+	service;
+	constructor(detail, service) {
+		super({
+			type: getErrorType("gateway-timeout"),
+			title: "Gateway Timeout",
+			status: 504,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "GatewayTimeoutError";
+		this.service = service;
+	}
+	toJSON() {
+		return {
+			...super.toJSON(),
+			...this.service && { service: this.service }
+		};
+	}
+};
+//#endregion
+//#region src/errors/server/http-version-not-supported-error.ts
+var HttpVersionNotSupportedError = class extends HttpError {
+	constructor(detail) {
+		super({
+			type: getErrorType("http-version-not-supported"),
+			title: "HTTP Version Not Supported",
+			status: 505,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "HttpVersionNotSupportedError";
+	}
+};
+//#endregion
+//#region src/errors/server/insufficient-storage-error.ts
+var InsufficientStorageError = class extends HttpError {
+	constructor(detail) {
+		super({
+			type: getErrorType("insufficient-storage"),
+			title: "Insufficient Storage",
+			status: 507,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "InsufficientStorageError";
+	}
+};
+//#endregion
+//#region src/errors/server/internal-server-error.ts
+var InternalServerError = class extends HttpError {
+	constructor(detail) {
+		super({
+			type: getErrorType("internal-server-error"),
+			title: "Internal Server Error",
+			status: 500,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "InternalServerError";
+	}
+};
+//#endregion
+//#region src/errors/server/loop-detected-error.ts
+var LoopDetectedError = class extends HttpError {
+	constructor(detail) {
+		super({
+			type: getErrorType("loop-detected"),
+			title: "Loop Detected",
+			status: 508,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "LoopDetectedError";
+	}
+};
+//#endregion
+//#region src/errors/server/network-authentication-required-error.ts
+var NetworkAuthenticationRequiredError = class extends HttpError {
+	constructor(detail) {
+		super({
+			type: getErrorType("network-authentication-required"),
+			title: "Network Authentication Required",
+			status: 511,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "NetworkAuthenticationRequiredError";
+	}
+};
+//#endregion
+//#region src/errors/server/not-extended-error.ts
+var NotExtendedError = class extends HttpError {
+	constructor(detail) {
+		super({
+			type: getErrorType("not-extended"),
+			title: "Not Extended",
+			status: 510,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "NotExtendedError";
+	}
+};
+//#endregion
+//#region src/errors/server/not-implemented-error.ts
+var NotImplementedError = class extends HttpError {
+	constructor(detail) {
+		super({
+			type: getErrorType("not-implemented"),
+			title: "Not Implemented",
+			status: 501,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "NotImplementedError";
+	}
+};
+//#endregion
+//#region src/errors/server/service-unavailable-error.ts
+var ServiceUnavailableError = class extends HttpError {
+	retryAfter;
+	constructor(detail, retryAfter) {
+		super({
+			type: getErrorType("service-unavailable"),
+			title: "Service Unavailable",
+			status: 503,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "ServiceUnavailableError";
+		this.retryAfter = retryAfter;
+	}
+	toJSON() {
+		return {
+			...super.toJSON(),
+			...this.retryAfter !== void 0 && { retryAfter: this.retryAfter }
+		};
+	}
+};
+//#endregion
+//#region src/errors/server/variant-also-negotiates-error.ts
+var VariantAlsoNegotiatesError = class extends HttpError {
+	constructor(detail) {
+		super({
+			type: getErrorType("variant-also-negotiates"),
+			title: "Variant Also Negotiates",
+			status: 506,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "VariantAlsoNegotiatesError";
+	}
+};
+//#endregion
+//#region src/helpers/create-error-by-status/index.ts
+const createErrorByStatus = (status, detail) => {
+	switch (status) {
+		case 400: return factories.badRequest(detail);
+		case 401: return factories.authentication(detail);
+		case 402: return factories.paymentRequired(detail);
+		case 403: return factories.authorization(detail);
+		case 404: return factories.notFound(detail);
+		case 405: return factories.methodNotAllowed(detail);
+		case 406: return factories.notAcceptable(detail);
+		case 407: return factories.proxyAuthenticationRequired(detail);
+		case 408: return factories.requestTimeout(detail);
+		case 409: return factories.conflict(detail);
+		case 410: return factories.gone(detail);
+		case 411: return factories.lengthRequired(detail);
+		case 412: return factories.preconditionFailed(detail);
+		case 413: return factories.payloadTooLarge(detail);
+		case 414: return factories.uriTooLong(detail);
+		case 415: return factories.unsupportedMediaType(detail);
+		case 416: return factories.rangeNotSatisfiable(detail);
+		case 417: return factories.expectationFailed(detail);
+		case 421: return factories.misdirectedRequest(detail);
+		case 422: return factories.validation(detail);
+		case 423: return factories.locked(detail);
+		case 424: return factories.failedDependency(detail);
+		case 425: return factories.tooEarly(detail);
+		case 426: return factories.upgradeRequired(detail);
+		case 428: return factories.preconditionRequired(detail);
+		case 429: return factories.rateLimit(detail);
+		case 431: return factories.requestHeaderFieldsTooLarge(detail);
+		case 451: return factories.unavailableForLegalReasons(detail);
+		case 500: return factories$1.internal(detail);
+		case 501: return factories$1.notImplemented(detail);
+		case 502: return factories$1.badGateway(detail);
+		case 503: return factories$1.serviceUnavailable(detail);
+		case 504: return factories$1.gatewayTimeout(detail);
+		case 505: return factories$1.httpVersionNotSupported(detail);
+		case 506: return factories$1.variantAlsoNegotiates(detail);
+		case 507: return factories$1.insufficientStorage(detail);
+		case 508: return factories$1.loopDetected(detail);
+		case 510: return factories$1.notExtended(detail);
+		case 511: return factories$1.networkAuthenticationRequired(detail);
+		default:
+			if (status >= 400 && status < 500) return factories.badRequest(detail);
+			return factories$1.internal(detail);
+	}
+};
+//#endregion
+//#region src/helpers/extract-cause/index.ts
+function extractCause(value) {
+	if (value instanceof Error) return value;
+}
+const currentConfig = { baseUrl: process.env.RFC9457_BASE_URL ?? "about:blank" };
+//#endregion
+//#region src/config/get-config.ts
+function getConfig() {
+	return currentConfig;
+}
+//#endregion
+//#region src/helpers/get-error-type/index.ts
+function getErrorType(name) {
+	const baseUrl = getConfig().baseUrl ?? "about:blank";
+	if (baseUrl === "about:blank") return `${baseUrl}#${name}`;
+	return `${baseUrl}/${name}`;
+}
+//#endregion
+//#region src/helpers/is-http-error/index.ts
+function isHttpError(error) {
+	return error instanceof HttpError;
+}
+//#endregion
+//#region src/helpers/is-valid-rfc9457-json/index.ts
+const isValidRFC9457Json = (data) => {
+	if (!data || typeof data !== "object") return false;
+	const obj = data;
+	return "type" in obj && "title" in obj && "status" in obj && "detail" in obj;
+};
+//#endregion
+//#region src/helpers/normalize-to-string/index.ts
+function normalizeToString(value) {
+	if (value instanceof Error) return value.message;
+	if (typeof value === "string") return value;
+	if (value === null || value === void 0) return "Unknown error";
+	if (typeof value === "object") try {
+		return JSON.stringify(value);
+	} catch {
+		return String(value);
+	}
+	return String(value);
+}
+//#endregion
+//#region src/errors/client/authentication-error.ts
+var AuthenticationError = class extends HttpError {
+	constructor(detail) {
+		super({
+			type: getErrorType("authentication"),
+			title: "Authentication Required",
+			status: 401,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "AuthenticationError";
+	}
+};
+//#endregion
+//#region src/errors/client/authorization-error.ts
+var AuthorizationError = class extends HttpError {
+	constructor(detail) {
+		super({
+			type: getErrorType("authorization"),
+			title: "Forbidden",
+			status: 403,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "AuthorizationError";
+	}
+};
+//#endregion
+//#region src/errors/client/bad-request-error.ts
+var BadRequestError = class extends HttpError {
+	constructor(detail) {
+		super({
+			type: getErrorType("bad-request"),
+			title: "Bad Request",
+			status: 400,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "BadRequestError";
+	}
+};
+//#endregion
+//#region src/errors/client/conflict-error.ts
+var ConflictError = class extends HttpError {
+	constructor(detail) {
+		super({
+			type: getErrorType("conflict"),
+			title: "Conflict",
+			status: 409,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "ConflictError";
+	}
+};
+//#endregion
+//#region src/errors/client/expectation-failed-error.ts
+var ExpectationFailedError = class extends HttpError {
+	constructor(detail) {
+		super({
+			type: getErrorType("expectation-failed"),
+			title: "Expectation Failed",
+			status: 417,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "ExpectationFailedError";
+	}
+};
+//#endregion
+//#region src/errors/client/factories.ts
+const standardFactories = {
+	badRequest: (detail) => new BadRequestError(detail),
+	paymentRequired: (detail) => new PaymentRequiredError(detail),
+	authentication: (detail) => new AuthenticationError(detail),
+	authorization: (detail) => new AuthorizationError(detail),
+	notFound: (resourceOrDetail, id) => new NotFoundError(resourceOrDetail, id),
+	methodNotAllowed: (detail) => new MethodNotAllowedError(detail),
+	notAcceptable: (detail) => new NotAcceptableError(detail),
+	proxyAuthenticationRequired: (detail) => new ProxyAuthenticationRequiredError(detail),
+	requestTimeout: (detail) => new RequestTimeoutError(detail),
+	conflict: (detail) => new ConflictError(detail),
+	gone: (detail) => new GoneError(detail),
+	lengthRequired: (detail) => new LengthRequiredError(detail),
+	preconditionFailed: (detail) => new PreconditionFailedError(detail),
+	payloadTooLarge: (detail, maxSize) => new PayloadTooLargeError(detail, maxSize),
+	uriTooLong: (detail) => new UriTooLongError(detail),
+	unsupportedMediaType: (detail) => new UnsupportedMediaTypeError(detail),
+	rangeNotSatisfiable: (detail) => new RangeNotSatisfiableError(detail),
+	expectationFailed: (detail) => new ExpectationFailedError(detail),
+	misdirectedRequest: (detail) => new MisdirectedRequestError(detail),
+	validation: (detail, validationErrors) => new ValidationError(detail, validationErrors),
+	locked: (detail) => new LockedError(detail),
+	failedDependency: (detail) => new FailedDependencyError(detail),
+	tooEarly: (detail) => new TooEarlyError(detail),
+	upgradeRequired: (detail) => new UpgradeRequiredError(detail),
+	preconditionRequired: (detail) => new PreconditionRequiredError(detail),
+	rateLimit: (detail, retryAfter) => new RateLimitError(detail, retryAfter),
+	requestHeaderFieldsTooLarge: (detail) => new RequestHeaderFieldsTooLargeError(detail),
+	unavailableForLegalReasons: (detail) => new UnavailableForLegalReasonsError(detail)
+};
+const aliases = {
+	validate: (detail, validationErrors) => standardFactories.validation(detail, validationErrors),
+	permission: (detail) => standardFactories.authorization(detail),
+	access: (detail) => standardFactories.authorization(detail),
+	idNotFound: (resourceOrDetail, id) => standardFactories.notFound(resourceOrDetail, id),
+	duplicate: (detail) => standardFactories.conflict(detail),
+	thirdParty: (detail) => standardFactories.failedDependency(detail)
+};
+const factories = {
+	...standardFactories,
+	...aliases
+};
+//#endregion
+//#region src/errors/client/failed-dependency-error.ts
+var FailedDependencyError = class extends HttpError {
+	constructor(detail) {
+		super({
+			type: getErrorType("failed-dependency"),
+			title: "Failed Dependency",
+			status: 424,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "FailedDependencyError";
+	}
+};
+//#endregion
+//#region src/errors/client/gone-error.ts
+var GoneError = class extends HttpError {
+	constructor(detail) {
+		super({
+			type: getErrorType("gone"),
+			title: "Gone",
+			status: 410,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "GoneError";
+	}
+};
+//#endregion
+//#region src/errors/client/length-required-error.ts
+var LengthRequiredError = class extends HttpError {
+	constructor(detail) {
+		super({
+			type: getErrorType("length-required"),
+			title: "Length Required",
+			status: 411,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "LengthRequiredError";
+	}
+};
+//#endregion
+//#region src/errors/client/locked-error.ts
+var LockedError = class extends HttpError {
+	constructor(detail) {
+		super({
+			type: getErrorType("locked"),
+			title: "Locked",
+			status: 423,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "LockedError";
+	}
+};
+//#endregion
+//#region src/errors/client/method-not-allowed-error.ts
+var MethodNotAllowedError = class extends HttpError {
+	constructor(detail) {
+		super({
+			type: getErrorType("method-not-allowed"),
+			title: "Method Not Allowed",
+			status: 405,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "MethodNotAllowedError";
+	}
+};
+//#endregion
+//#region src/errors/client/misdirected-request-error.ts
+var MisdirectedRequestError = class extends HttpError {
+	constructor(detail) {
+		super({
+			type: getErrorType("misdirected-request"),
+			title: "Misdirected Request",
+			status: 421,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "MisdirectedRequestError";
+	}
+};
+//#endregion
+//#region src/errors/client/not-acceptable-error.ts
+var NotAcceptableError = class extends HttpError {
+	constructor(detail) {
+		super({
+			type: getErrorType("not-acceptable"),
+			title: "Not Acceptable",
+			status: 406,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "NotAcceptableError";
+	}
+};
+//#endregion
+//#region src/errors/client/not-found-error.ts
+var NotFoundError = class extends HttpError {
+	constructor(resourceOrDetail, id) {
+		let detail;
+		if (id === void 0) detail = normalizeToString(resourceOrDetail);
+		else detail = `${String(resourceOrDetail)} ${id} not found`;
+		super({
+			type: getErrorType("not-found"),
+			title: "Not Found",
+			status: 404,
+			detail,
+			cause: id === void 0 ? extractCause(resourceOrDetail) : void 0
+		});
+		this.name = "NotFoundError";
+	}
+};
+//#endregion
+//#region src/errors/client/payload-too-large-error.ts
+var PayloadTooLargeError = class extends HttpError {
+	maxSize;
+	constructor(detail, maxSize) {
+		super({
+			type: getErrorType("payload-too-large"),
+			title: "Payload Too Large",
+			status: 413,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "PayloadTooLargeError";
+		this.maxSize = maxSize;
+	}
+	toJSON() {
+		return {
+			...super.toJSON(),
+			...this.maxSize !== void 0 && { maxSize: this.maxSize }
+		};
+	}
+};
+//#endregion
+//#region src/errors/client/payment-required-error.ts
+var PaymentRequiredError = class extends HttpError {
+	constructor(detail) {
+		super({
+			type: getErrorType("payment-required"),
+			title: "Payment Required",
+			status: 402,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "PaymentRequiredError";
+	}
+};
+//#endregion
+//#region src/errors/client/precondition-failed-error.ts
+var PreconditionFailedError = class extends HttpError {
+	constructor(detail) {
+		super({
+			type: getErrorType("precondition-failed"),
+			title: "Precondition Failed",
+			status: 412,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "PreconditionFailedError";
+	}
+};
+//#endregion
+//#region src/errors/client/precondition-required-error.ts
+var PreconditionRequiredError = class extends HttpError {
+	constructor(detail) {
+		super({
+			type: getErrorType("precondition-required"),
+			title: "Precondition Required",
+			status: 428,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "PreconditionRequiredError";
+	}
+};
+//#endregion
+//#region src/errors/client/proxy-authentication-required-error.ts
+var ProxyAuthenticationRequiredError = class extends HttpError {
+	constructor(detail) {
+		super({
+			type: getErrorType("proxy-authentication-required"),
+			title: "Proxy Authentication Required",
+			status: 407,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "ProxyAuthenticationRequiredError";
+	}
+};
+//#endregion
+//#region src/errors/client/range-not-satisfiable-error.ts
+var RangeNotSatisfiableError = class extends HttpError {
+	constructor(detail) {
+		super({
+			type: getErrorType("range-not-satisfiable"),
+			title: "Range Not Satisfiable",
+			status: 416,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "RangeNotSatisfiableError";
+	}
+};
+//#endregion
+//#region src/errors/client/rate-limit-error.ts
+var RateLimitError = class extends HttpError {
+	retryAfter;
+	constructor(detail, retryAfter) {
+		super({
+			type: getErrorType("rate-limit"),
+			title: "Too Many Requests",
+			status: 429,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "RateLimitError";
+		this.retryAfter = retryAfter;
+	}
+	toJSON() {
+		return {
+			...super.toJSON(),
+			...this.retryAfter !== void 0 && { retryAfter: this.retryAfter }
+		};
+	}
+};
+//#endregion
+//#region src/errors/client/request-header-fields-too-large-error.ts
+var RequestHeaderFieldsTooLargeError = class extends HttpError {
+	constructor(detail) {
+		super({
+			type: getErrorType("request-header-fields-too-large"),
+			title: "Request Header Fields Too Large",
+			status: 431,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "RequestHeaderFieldsTooLargeError";
+	}
+};
+//#endregion
+//#region src/errors/client/request-timeout-error.ts
+var RequestTimeoutError = class extends HttpError {
+	constructor(detail) {
+		super({
+			type: getErrorType("request-timeout"),
+			title: "Request Timeout",
+			status: 408,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "RequestTimeoutError";
+	}
+};
+//#endregion
+//#region src/errors/client/too-early-error.ts
+var TooEarlyError = class extends HttpError {
+	constructor(detail) {
+		super({
+			type: getErrorType("too-early"),
+			title: "Too Early",
+			status: 425,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "TooEarlyError";
+	}
+};
+//#endregion
+//#region src/errors/client/unavailable-for-legal-reasons-error.ts
+var UnavailableForLegalReasonsError = class extends HttpError {
+	constructor(detail) {
+		super({
+			type: getErrorType("unavailable-for-legal-reasons"),
+			title: "Unavailable For Legal Reasons",
+			status: 451,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "UnavailableForLegalReasonsError";
+	}
+};
+//#endregion
+//#region src/errors/client/unsupported-media-type-error.ts
+var UnsupportedMediaTypeError = class extends HttpError {
+	constructor(detail) {
+		super({
+			type: getErrorType("unsupported-media-type"),
+			title: "Unsupported Media Type",
+			status: 415,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "UnsupportedMediaTypeError";
+	}
+};
+//#endregion
+//#region src/errors/client/upgrade-required-error.ts
+var UpgradeRequiredError = class extends HttpError {
+	constructor(detail) {
+		super({
+			type: getErrorType("upgrade-required"),
+			title: "Upgrade Required",
+			status: 426,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "UpgradeRequiredError";
+	}
+};
+//#endregion
+//#region src/errors/client/uri-too-long-error.ts
+var UriTooLongError = class extends HttpError {
+	constructor(detail) {
+		super({
+			type: getErrorType("uri-too-long"),
+			title: "URI Too Long",
+			status: 414,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "UriTooLongError";
+	}
+};
+//#endregion
+//#region src/errors/client/validation-error.ts
+var ValidationError = class extends HttpError {
+	validationErrors;
+	constructor(detail, validationErrors) {
+		super({
+			type: getErrorType("validation"),
+			title: "Validation Error",
+			status: 422,
+			detail: normalizeToString(detail),
+			cause: extractCause(detail)
+		});
+		this.name = "ValidationError";
+		this.validationErrors = validationErrors;
+	}
+	toJSON() {
+		return {
+			...super.toJSON(),
+			...this.validationErrors && { validationErrors: this.validationErrors }
+		};
+	}
+};
+//#endregion
+//#region src/error.ts
+const error = {
+	...factories,
+	...factories$1
+};
+//#endregion
+//#region src/errors.ts
+const errors = {
+	client: factories,
+	server: factories$1,
+	byStatus: createErrorByStatus
+};
+//#endregion
+export { error, errors, isHttpError, isValidRFC9457Json };