HTTP unauthorized error(401).

@param {String} [message]
@param {*} [cause]
@constructor
@memberOf errors
14593
function Unauthorized(message, cause) {
    Unauthorized.super_.call(this, message, StatusCode.UNAUTHORIZED, cause);
}
659432
function ErrorLocked (message) {

  Error.call(this);

  // Add Information
  this.name    = 'ErrorLocked';
  this.type    = 'client';
  this.status  = 423;
  if (message) {
    this.message = message;
  }

}
131832
function(err, data) {

            if(!err) {

                me.loggedin = true;
                fn(err, data);

            } else {

                me.loggedin = false;
                fn({code:SMTPError.AUTHFAILED, message:"authorization failed", smtp:data});

            }
        }
301023
function(message, response) {
    HttpError.call(this, message, code, description, response, false)
    Error.captureStackTrace(this, arguments.callee)
  }
834648
function RAgent_onResponse(message) {
  var reqID = message.id

  if (!this._requestCBs.has(reqID)) return

  var cb = this._requestCBs.get(reqID)
  this._requestCBs.delete(reqID)

  if (message.error) {
    var err = new Error(message.error)
    return cb(err, message.body)
  }

  cb(null, message.body)
}
1285866
function message(violation, suggestion, condition, joiner) {
  var reason =
    join(quotation(violation, '`'), joiner) +
    ' may be insensitive' +
    (condition ? ', ' + condition : '') +
    ', '

  if (suggestion) {
    reason += 'use ' + join(quotation(suggestion, '`'), joiner) + ' instead'
  } else {
    reason += 'try not to use it'
  }

  return reason
}
199592
def unauthorized(msg = t('flashes.failure_when_not_signed_in'))
      authenticate_session.logout
      respond_to do |format|
        format.any(:js, :json, :xml) { head :unauthorized }
        format.any { redirect_unauthorized(msg) }
      end
    end
735452
function OAuth2Error(message, code, uri, status) {
  Error.call(this);
  this.message = message;
  this.code = code || 'server_error';
  this.uri = uri;
  this.status = status || 500;
}
669752
function ParserError(message) {
    this.message = message;
    this.name = 'ParserError';

    try {
      throw new Error();
    } catch (e) {
      if (e.stack) {
        var split = e.stack.split('\n');
        split.shift();
        this.stack = split.join('\n');
      }
    }
  }
856463
function(message) {
            if(!aborted) {
                message = typeof message == 'string' ? message : 'Connection aborted';
                promise.abort();
                promise(false, [new Error(message), xhr, null]);
            }
        }
631641
function httpInternalError(req, res, err) {
    console.error(err);
    res.writeHead(500, { 'Content-Type': 'text/plain' });
    res.write(`Error 500 Internal server error: ${err}`);
    res.end();
}
911320
def not_authorized!(*args)
        options = args.extract_options!
        message = options[:message] ||
          I18n.t('action_access.redirection_message', default: 'Not authorized.')
        path = options[:path] || unauthorized_access_redirection_path
        redirect_to path, alert: message
      end
578944
def respond_unauthorized(self, request_authentication=False):
		
		headers = {}
		if request_authentication:
			headers['WWW-Authenticate'] = 'Basic realm="' + self.__config['server_version'] + '"'
		self.send_response_full(b'Unauthorized', status=401, headers=headers)
		return
666758
def process_errors(response)
      if response['errors']
        errors = 'The server responded with the following error(s): '
        errors << response['errors'].join(',')

        if errors.include?('Not authorized')
          Awesomekit::Authenticator.clear_api_token
        end

        puts(errors)

        return true
      end
    end
206333
function err(...messages) {
  console.error(...messages);
  const p = document.createElement('p');
  p.innerText = messages.join(' ');
  p.style = 'color: red';
  logElement.appendChild(p);
}
1062724
protected function unauthorizedException(Request $request, Response $response, $message = 'Unauthorized.')
    {
        return new UnauthorizedException($request, $response, $message);
    }
1221046
function  (options, status) {
  this.name = ''
  this.error = options.error
  this.error_description = options.error_description
  this.realm = options.realm
  this.scope = options.scope
  this.statusCode = options.statusCode || 401
}