export function isHDBError(e: any): boolean;
/**
 * This handler method is used to effectively evaluate caught errors and either translates them into a custom HdbError or,
 * if it is already a HdbError, just returns the error to continue being thrown up the stack
 *
 * See above for params descriptions
 * @param e
 * @param httpMsg
 * @param httpCode
 * @param logLevel
 * @param logMsg
 * @param deleteStack
 * @returns {HdbError|*}
 */
export function handleHDBError(e: any, httpMsg: any, httpCode: any, logLevel?: "error", logMsg?: any, deleteStack?: boolean): HdbError | any;
export class ClientError extends Error {
    constructor(message: any, statusCode: any);
    statusCode: any;
}
export class ServerError extends Error {
    constructor(message: any, statusCode: any);
    statusCode: any;
}
/**
 * Represents an access violation. This is used to return a 403 or 401 response to the client. Uses fast Violation class
 * to avoid stack trace capture.
 * @param {Object} user - user object that caused the access violation
 * @constructor
 */
export class AccessViolation extends Violation {
    constructor(user: any);
    statusCode: number;
}
/**
 * Represents a general violation of validation/authorization. This should be used in situations where we are performing
 * expected verification, and we do not need to record a stack trace. This extends Error's prototype, but doesn't
 * use the native constructor to avoid stack trace capture which is several times faster.
 * @param {Object} user - user object that caused the access violation
 * @constructor
 */
export function Violation(message: any): void;
export class Violation {
    /**
     * Represents a general violation of validation/authorization. This should be used in situations where we are performing
     * expected verification, and we do not need to record a stack trace. This extends Error's prototype, but doesn't
     * use the native constructor to avoid stack trace capture which is several times faster.
     * @param {Object} user - user object that caused the access violation
     * @constructor
     */
    constructor(message: any);
    message: any;
    toString(): string;
}
import hdbErrors = require("./commonErrors.js");
/**
 * Custom error class used for better error and log handling.  Caught errors that evaluate to an instanceof HdbError can
 * be handled differently - e.g. in most cases caught HdbError likely would not need to be logged since that should have
 * already been handled when the custom error was constructed.
 */
declare class HdbError extends Error {
    /**
     * @param {Error} errOrig -  Error to be translated into HdbError. If manually throwing an error, pass `new Error()` to ensure stack trace is maintained
     * @param {String} [httpMsg] - optional -  response message that will be returned via the API
     * @param {Number} [httpCode] - optional -  response status code that will be returned via the API
     * @param {String} [logLevel] - optional -  log level that will be used for logging of this error
     * @param {String} [logMsg] - optional - log message that, if provided, will be logged at the `logLevel` above
     */
    constructor(errOrig: Error, httpMsg?: string, httpCode?: number, logLevel?: string, logMsg?: string);
    statusCode: number;
    http_resp_msg: any;
    message: any;
    type: string;
    logLevel: string;
    stack: string;
}
export { hdbErrors };
