import { BaseError, mergeOptions, buildOptions, buildMessage, extendsBaseError } from 'ebec';
export { BaseError, buildMessage, buildOptions, extendsBaseError, mergeOptions } from 'ebec';

class ClientError extends BaseError {
}

class ServerError extends BaseError {
}

const BadRequestErrorOptions = {
    code: `BAD_REQUEST`,
    statusCode: 400,
    decorateMessage: false,
    logMessage: false,
    message: `Bad Request`
};
class BadRequestError extends ClientError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), BadRequestErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Bad Request`;
        }
        super(message, options);
    }
}

const UnauthorizedErrorOptions = {
    code: `UNAUTHORIZED`,
    statusCode: 401,
    decorateMessage: false,
    logMessage: false,
    message: `Unauthorized`
};
class UnauthorizedError extends ClientError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), UnauthorizedErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Unauthorized`;
        }
        super(message, options);
    }
}

const ForbiddenErrorOptions = {
    code: `FORBIDDEN`,
    statusCode: 403,
    decorateMessage: false,
    logMessage: false,
    message: `Forbidden`
};
class ForbiddenError extends ClientError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), ForbiddenErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Forbidden`;
        }
        super(message, options);
    }
}

const NotFoundErrorOptions = {
    code: `NOT_FOUND`,
    statusCode: 404,
    decorateMessage: false,
    logMessage: false,
    message: `Not Found`
};
class NotFoundError extends ClientError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), NotFoundErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Not Found`;
        }
        super(message, options);
    }
}

const MethodNotAllowedErrorOptions = {
    code: `METHOD_NOT_ALLOWED`,
    statusCode: 405,
    decorateMessage: false,
    logMessage: false,
    message: `Method Not Allowed`
};
class MethodNotAllowedError extends ClientError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), MethodNotAllowedErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Method Not Allowed`;
        }
        super(message, options);
    }
}

const NotAcceptableErrorOptions = {
    code: `NOT_ACCEPTABLE`,
    statusCode: 406,
    decorateMessage: false,
    logMessage: false,
    message: `Not Acceptable`
};
class NotAcceptableError extends ClientError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), NotAcceptableErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Not Acceptable`;
        }
        super(message, options);
    }
}

const ProxyAuthenticationRequiredErrorOptions = {
    code: `PROXY_AUTHENTICATION_REQUIRED`,
    statusCode: 407,
    decorateMessage: false,
    logMessage: false,
    message: `Proxy Authentication Required`
};
class ProxyAuthenticationRequiredError extends ClientError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), ProxyAuthenticationRequiredErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Proxy Authentication Required`;
        }
        super(message, options);
    }
}

const RequestTimeoutErrorOptions = {
    code: `REQUEST_TIMEOUT`,
    statusCode: 408,
    decorateMessage: false,
    logMessage: false,
    message: `Request Timeout`
};
class RequestTimeoutError extends ClientError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), RequestTimeoutErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Request Timeout`;
        }
        super(message, options);
    }
}

const ConflictErrorOptions = {
    code: `CONFLICT`,
    statusCode: 409,
    decorateMessage: false,
    logMessage: false,
    message: `Conflict`
};
class ConflictError extends ClientError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), ConflictErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Conflict`;
        }
        super(message, options);
    }
}

const GoneErrorOptions = {
    code: `GONE`,
    statusCode: 410,
    decorateMessage: false,
    logMessage: false,
    message: `Gone`
};
class GoneError extends ClientError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), GoneErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Gone`;
        }
        super(message, options);
    }
}

const LengthRequiredErrorOptions = {
    code: `LENGTH_REQUIRED`,
    statusCode: 411,
    decorateMessage: false,
    logMessage: false,
    message: `Length Required`
};
class LengthRequiredError extends ClientError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), LengthRequiredErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Length Required`;
        }
        super(message, options);
    }
}

const PreconditionFailedErrorOptions = {
    code: `PRECONDITION_FAILED`,
    statusCode: 412,
    decorateMessage: false,
    logMessage: false,
    message: `Precondition Failed`
};
class PreconditionFailedError extends ClientError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), PreconditionFailedErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Precondition Failed`;
        }
        super(message, options);
    }
}

const RequestEntityTooLargeErrorOptions = {
    code: `REQUEST_ENTITY_TOO_LARGE`,
    statusCode: 413,
    decorateMessage: false,
    logMessage: false,
    message: `REQUEST_ENTITY_TOO_LARGE`
};
class RequestEntityTooLargeError extends ClientError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), RequestEntityTooLargeErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `REQUEST_ENTITY_TOO_LARGE`;
        }
        super(message, options);
    }
}

const RequestURITooLongErrorOptions = {
    code: `REQUEST_URI_TOO_LONG`,
    statusCode: 414,
    decorateMessage: false,
    logMessage: false,
    message: `Request-URI Too Long`
};
class RequestURITooLongError extends ClientError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), RequestURITooLongErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Request-URI Too Long`;
        }
        super(message, options);
    }
}

const UnsupportedMediaTypeErrorOptions = {
    code: `UNSUPPORTED_MEDIA_TYPE`,
    statusCode: 415,
    decorateMessage: false,
    logMessage: false,
    message: `Unsupported Media Type`
};
class UnsupportedMediaTypeError extends ClientError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), UnsupportedMediaTypeErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Unsupported Media Type`;
        }
        super(message, options);
    }
}

const RequestedRangeNotSatisfiableErrorOptions = {
    code: `REQUESTED_RANGE_NOT_SATISFIABLE`,
    statusCode: 416,
    decorateMessage: false,
    logMessage: false,
    message: `Requested Range Not Satisfiable`
};
class RequestedRangeNotSatisfiableError extends ClientError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), RequestedRangeNotSatisfiableErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Requested Range Not Satisfiable`;
        }
        super(message, options);
    }
}

const ExpectationFailedErrorOptions = {
    code: `EXPECTATION_FAILED`,
    statusCode: 417,
    decorateMessage: false,
    logMessage: false,
    message: `Expectation Failed`
};
class ExpectationFailedError extends ClientError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), ExpectationFailedErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Expectation Failed`;
        }
        super(message, options);
    }
}

const ImATeapotErrorOptions = {
    code: `IM_A_TEAPOT`,
    statusCode: 418,
    decorateMessage: false,
    logMessage: false,
    message: `I&#39;m a Teapot`
};
class ImATeapotError extends ClientError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), ImATeapotErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `I'm a Teapot`;
        }
        super(message, options);
    }
}

const EnhanceYourCalmErrorOptions = {
    code: `ENHANCE_YOUR_CALM`,
    statusCode: 420,
    decorateMessage: false,
    logMessage: false,
    message: `Enhance Your Calm`
};
class EnhanceYourCalmError extends ClientError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), EnhanceYourCalmErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Enhance Your Calm`;
        }
        super(message, options);
    }
}

const UnprocessableEntityErrorOptions = {
    code: `UNPROCESSABLE_ENTITY`,
    statusCode: 422,
    decorateMessage: false,
    logMessage: false,
    message: `Unprocessable Entity`
};
class UnprocessableEntityError extends ClientError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), UnprocessableEntityErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Unprocessable Entity`;
        }
        super(message, options);
    }
}

const LockedErrorOptions = {
    code: `LOCKED`,
    statusCode: 423,
    decorateMessage: false,
    logMessage: false,
    message: `Locked`
};
class LockedError extends ClientError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), LockedErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Locked`;
        }
        super(message, options);
    }
}

const FailedDependencyErrorOptions = {
    code: `FAILED_DEPENDENCY`,
    statusCode: 424,
    decorateMessage: false,
    logMessage: false,
    message: `Failed Dependency`
};
class FailedDependencyError extends ClientError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), FailedDependencyErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Failed Dependency`;
        }
        super(message, options);
    }
}

const UnorderedCollectionErrorOptions = {
    code: `UNORDERED_COLLECTION`,
    statusCode: 425,
    decorateMessage: false,
    logMessage: false,
    message: `Unordered Collection`
};
class UnorderedCollectionError extends ClientError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), UnorderedCollectionErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Unordered Collection`;
        }
        super(message, options);
    }
}

const UpgradeRequiredErrorOptions = {
    code: `UPGRADE_REQUIRED`,
    statusCode: 426,
    decorateMessage: false,
    logMessage: false,
    message: `Upgrade Required`
};
class UpgradeRequiredError extends ClientError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), UpgradeRequiredErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Upgrade Required`;
        }
        super(message, options);
    }
}

const PreconditionRequiredErrorOptions = {
    code: `PRECONDITION_REQUIRED`,
    statusCode: 428,
    decorateMessage: false,
    logMessage: false,
    message: `Precondition Required`
};
class PreconditionRequiredError extends ClientError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), PreconditionRequiredErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Precondition Required`;
        }
        super(message, options);
    }
}

const TooManyRequestsErrorOptions = {
    code: `TOO_MANY_REQUESTS`,
    statusCode: 429,
    decorateMessage: false,
    logMessage: false,
    message: `Too Many Requests`
};
class TooManyRequestsError extends ClientError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), TooManyRequestsErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Too Many Requests`;
        }
        super(message, options);
    }
}

const RequestHeaderFieldsTooLargeErrorOptions = {
    code: `REQUEST_HEADER_FIELDS_TOO_LARGE`,
    statusCode: 431,
    decorateMessage: false,
    logMessage: false,
    message: `Request Header Fields Too Large`
};
class RequestHeaderFieldsTooLargeError extends ClientError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), RequestHeaderFieldsTooLargeErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Request Header Fields Too Large`;
        }
        super(message, options);
    }
}

const NoResponseErrorOptions = {
    code: `NO_RESPONSE`,
    statusCode: 444,
    decorateMessage: false,
    logMessage: false,
    message: `No Response`
};
class NoResponseError extends ClientError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), NoResponseErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `No Response`;
        }
        super(message, options);
    }
}

const RetryWithErrorOptions = {
    code: `RETRY_WITH`,
    statusCode: 449,
    decorateMessage: false,
    logMessage: false,
    message: `Retry With`
};
class RetryWithError extends ClientError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), RetryWithErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Retry With`;
        }
        super(message, options);
    }
}

const BlockedByWindowsParentalControlsErrorOptions = {
    code: `BLOCKED_BY_WINDOWS_PARENTAL_CONTROLS`,
    statusCode: 450,
    decorateMessage: false,
    logMessage: false,
    message: `Blocked By Windows Parental Controls`
};
class BlockedByWindowsParentalControlsError extends ClientError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), BlockedByWindowsParentalControlsErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Blocked By Windows Parental Controls`;
        }
        super(message, options);
    }
}

const ClientClosedRequestErrorOptions = {
    code: `CLIENT_CLOSED_REQUEST`,
    statusCode: 499,
    decorateMessage: false,
    logMessage: false,
    message: `Client Closed Request`
};
class ClientClosedRequestError extends ClientError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), ClientClosedRequestErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Client Closed Request`;
        }
        super(message, options);
    }
}

const InternalServerErrorOptions = {
    code: `INTERNAL_SERVER_ERROR`,
    statusCode: 500,
    decorateMessage: true,
    logMessage: true,
    message: `Internal Server Error`
};
class InternalServerError extends ServerError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), InternalServerErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Internal Server Error`;
        }
        super(message, options);
    }
}

const NotImplementedErrorOptions = {
    code: `NOT_IMPLEMENTED`,
    statusCode: 501,
    decorateMessage: true,
    logMessage: true,
    message: `Not Implemented`
};
class NotImplementedError extends ServerError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), NotImplementedErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Not Implemented`;
        }
        super(message, options);
    }
}

const BadGatewayErrorOptions = {
    code: `BAD_GATEWAY`,
    statusCode: 502,
    decorateMessage: true,
    logMessage: true,
    message: `Bad Gateway`
};
class BadGatewayError extends ServerError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), BadGatewayErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Bad Gateway`;
        }
        super(message, options);
    }
}

const ServiceUnavailableErrorOptions = {
    code: `SERVICE_UNAVAILABLE`,
    statusCode: 503,
    decorateMessage: true,
    logMessage: true,
    message: `Service Unavailable`
};
class ServiceUnavailableError extends ServerError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), ServiceUnavailableErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Service Unavailable`;
        }
        super(message, options);
    }
}

const GatewayTimeoutErrorOptions = {
    code: `GATEWAY_TIMEOUT`,
    statusCode: 504,
    decorateMessage: true,
    logMessage: true,
    message: `Gateway Timeout`
};
class GatewayTimeoutError extends ServerError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), GatewayTimeoutErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Gateway Timeout`;
        }
        super(message, options);
    }
}

const HTTPVersionNotSupportedErrorOptions = {
    code: `HTTP_VERSION_NOT_SUPPORTED`,
    statusCode: 505,
    decorateMessage: true,
    logMessage: true,
    message: `HTTP Version Not Supported`
};
class HTTPVersionNotSupportedError extends ServerError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), HTTPVersionNotSupportedErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `HTTP Version Not Supported`;
        }
        super(message, options);
    }
}

const VariantAlsoNegotiatesErrorOptions = {
    code: `VARIANT_ALSO_NEGOTIATES`,
    statusCode: 506,
    decorateMessage: true,
    logMessage: true,
    message: `Variant Also Negotiates`
};
class VariantAlsoNegotiatesError extends ServerError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), VariantAlsoNegotiatesErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Variant Also Negotiates`;
        }
        super(message, options);
    }
}

const InsufficientStorageErrorOptions = {
    code: `INSUFFICIENT_STORAGE`,
    statusCode: 507,
    decorateMessage: true,
    logMessage: true,
    message: `Insufficient Storage`
};
class InsufficientStorageError extends ServerError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), InsufficientStorageErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Insufficient Storage`;
        }
        super(message, options);
    }
}

const LoopDetectedErrorOptions = {
    code: `LOOP_DETECTED`,
    statusCode: 508,
    decorateMessage: true,
    logMessage: true,
    message: `Loop Detected`
};
class LoopDetectedError extends ServerError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), LoopDetectedErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Loop Detected`;
        }
        super(message, options);
    }
}

const BandwidthLimitExceededErrorOptions = {
    code: `BANDWIDTH_LIMIT_EXCEEDED`,
    statusCode: 509,
    decorateMessage: true,
    logMessage: true,
    message: `Bandwidth Limit Exceeded`
};
class BandwidthLimitExceededError extends ServerError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), BandwidthLimitExceededErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Bandwidth Limit Exceeded`;
        }
        super(message, options);
    }
}

const NotExtendedErrorOptions = {
    code: `NOT_EXTENDED`,
    statusCode: 510,
    decorateMessage: true,
    logMessage: true,
    message: `Not Extended`
};
class NotExtendedError extends ServerError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), NotExtendedErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Not Extended`;
        }
        super(message, options);
    }
}

const NetworkAuthenticationRequiredErrorOptions = {
    code: `NETWORK_AUTHENTICATION_REQUIRED`,
    statusCode: 511,
    decorateMessage: true,
    logMessage: true,
    message: `Network Authentication Required`
};
class NetworkAuthenticationRequiredError extends ServerError {
    constructor(data, options){
        options = mergeOptions(buildOptions(data, options), NetworkAuthenticationRequiredErrorOptions);
        let message = buildMessage(data, options);
        if (!message) {
            message = `Network Authentication Required`;
        }
        super(message, options);
    }
}

function extendsClientError(error) {
    if (error instanceof ClientError) {
        return true;
    }
    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
    // @ts-ignore
    return extendsBaseError(error) && (error.getOption('statusCode') >= 400 || error.getOption('statusCode') < 500);
}
function extendsServerError(error) {
    if (error instanceof ServerError) {
        return true;
    }
    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
    // @ts-ignore
    return extendsBaseError(error) && (error.getOption('statusCode') >= 500 || error.getOption('statusCode') < 600);
}

export { BadGatewayError, BadGatewayErrorOptions, BadRequestError, BadRequestErrorOptions, BandwidthLimitExceededError, BandwidthLimitExceededErrorOptions, BlockedByWindowsParentalControlsError, BlockedByWindowsParentalControlsErrorOptions, ClientClosedRequestError, ClientClosedRequestErrorOptions, ClientError, ConflictError, ConflictErrorOptions, EnhanceYourCalmError, EnhanceYourCalmErrorOptions, ExpectationFailedError, ExpectationFailedErrorOptions, FailedDependencyError, FailedDependencyErrorOptions, ForbiddenError, ForbiddenErrorOptions, GatewayTimeoutError, GatewayTimeoutErrorOptions, GoneError, GoneErrorOptions, HTTPVersionNotSupportedError, HTTPVersionNotSupportedErrorOptions, ImATeapotError, ImATeapotErrorOptions, InsufficientStorageError, InsufficientStorageErrorOptions, InternalServerError, InternalServerErrorOptions, LengthRequiredError, LengthRequiredErrorOptions, LockedError, LockedErrorOptions, LoopDetectedError, LoopDetectedErrorOptions, MethodNotAllowedError, MethodNotAllowedErrorOptions, NetworkAuthenticationRequiredError, NetworkAuthenticationRequiredErrorOptions, NoResponseError, NoResponseErrorOptions, NotAcceptableError, NotAcceptableErrorOptions, NotExtendedError, NotExtendedErrorOptions, NotFoundError, NotFoundErrorOptions, NotImplementedError, NotImplementedErrorOptions, PreconditionFailedError, PreconditionFailedErrorOptions, PreconditionRequiredError, PreconditionRequiredErrorOptions, ProxyAuthenticationRequiredError, ProxyAuthenticationRequiredErrorOptions, RequestEntityTooLargeError, RequestEntityTooLargeErrorOptions, RequestHeaderFieldsTooLargeError, RequestHeaderFieldsTooLargeErrorOptions, RequestTimeoutError, RequestTimeoutErrorOptions, RequestURITooLongError, RequestURITooLongErrorOptions, RequestedRangeNotSatisfiableError, RequestedRangeNotSatisfiableErrorOptions, RetryWithError, RetryWithErrorOptions, ServerError, ServiceUnavailableError, ServiceUnavailableErrorOptions, TooManyRequestsError, TooManyRequestsErrorOptions, UnauthorizedError, UnauthorizedErrorOptions, UnorderedCollectionError, UnorderedCollectionErrorOptions, UnprocessableEntityError, UnprocessableEntityErrorOptions, UnsupportedMediaTypeError, UnsupportedMediaTypeErrorOptions, UpgradeRequiredError, UpgradeRequiredErrorOptions, VariantAlsoNegotiatesError, VariantAlsoNegotiatesErrorOptions, extendsClientError, extendsServerError };
//# sourceMappingURL=index.mjs.map
