Gets if Serial Console is disabled for a subscription.

 @param custom_headers [Hash{String => String}] A hash of custom headers that
 will be added to the HTTP request.

 @return [GetDisabledResult] operation results.
169255
def disabled(custom_headers:nil)
      response = disabled_async(custom_headers:custom_headers).value!
      response.body unless response.nil?
    end
1284437
def getheader(self, which, use_hash=None, polish=True):
        """"""
        header = getheader(
            which,
            use_hash=use_hash,
            target=self.target,
            no_tco=self.no_tco,
            strict=self.strict,
        )
        if polish:
            header = self.polish(header)
        return header
382623
def list_available_response_headers(custom_headers:nil)
      response = list_available_response_headers_async(custom_headers:custom_headers).value!
      response.body unless response.nil?
    end
674902
def generic_http_header_parser_for(header_name):
    

    def parser():
        request_id = request.headers.get(header_name, '').strip()

        if not request_id:
            # If the request id is empty return None
            return None
        return request_id
    return parser
26702
def list_built_in_as_lazy(custom_headers:nil)
      response = list_built_in_async(custom_headers:custom_headers).value!
      unless response.nil?
        page = response.body
        page.next_method = Proc.new do |next_page_link|
          list_built_in_next_async(next_page_link, custom_headers:custom_headers)
        end
        page
      end
    end
644632
def p_if_header(p):
    
    global ENABLED

    IFDEFS.append((ENABLED, p.lineno(2)))
    ENABLED = ID_TABLE.defined(p[2])
990249
@Sensitive
    public Hashtable<String, ?> getSensitiveHashtableFromSubject(@Sensitive final Subject subject, @Sensitive final String[] properties) {
        return AccessController.doPrivileged(new PrivilegedAction<Hashtable<String, ?>>() {
            @Override
            public Hashtable<String, ?> run() {
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                    Tr.debug(tc, "Looking for custom properties in public cred list.");
                }
                Set<Object> list_public = subject.getPublicCredentials();
                Hashtable<String, ?> hashtableFromPublic = getSensitiveHashtable(list_public, properties);
                if (hashtableFromPublic != null) {
                    return hashtableFromPublic;
                }

                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                    Tr.debug(tc, "Looking for custom properties in private cred list.");
                }
                Set<Object> list_private = subject.getPrivateCredentials();
                Hashtable<String, ?> hashtableFromPrivate = getSensitiveHashtable(list_private, properties);
                if (hashtableFromPrivate != null) {
                    return hashtableFromPrivate;
                }

                return null;
            }
        });
    }
827891
def get_disabled():
    '''
    
    '''
    (enabled_services, disabled_services) = _get_service_list(include_enabled=False,
                                                              include_disabled=True)
    return sorted(disabled_services)
403382
def _get_all_headers(self, method, endpoint, request_bytes, custom_headers):
        

        headers = self._get_default_headers()
        headers.update(custom_headers)

        if self._api_context.token is not None:
            headers[self.HEADER_AUTHENTICATION] = self._api_context.token
            headers[self.HEADER_SIGNATURE] = security.sign_request(
                self._api_context.installation_context.private_key_client,
                method,
                endpoint,
                request_bytes,
                headers
            )

        return headers
1209991
static String getSingleHeader(HTTPResponse resp, String headerName) {
    return Iterables.getOnlyElement(getHeaders(resp, headerName)).getValue();
  }
1321788
def authorized?(options = {})
      raise "Configuration values not found. Please run rails g restful_api_authentication:install to generate a config file." if @@header_timestamp.nil? || @@header_signature.nil? || @@header_api_key.nil? || @@time_window.nil? || @@disabled_message.nil?
      return_val = false
      if headers_have_values?
        if in_time_window?
          if test_hash.downcase == @http_headers[@@header_signature].downcase
            if is_disabled?
              @errors << @@disabled_message
              return false
            end
            if options[:require_master] == true
              if is_master?
                return_val = true
              else
                @errors << "client does not have the required permissions"
              end
            else
              return_val = true
            end
          else
            @errors << "signature is invalid"
          end
        else
          @errors << "request is outside the required time window of #{@@time_window.to_s} minutes"
        end
      else
        @errors << "one or more required headers is missing"
      end
      if return_val == false && @errors.count == 0
        @errors << "authentication failed"
      end
      return_val
    end
229981
def system_headers(input_params={}, always_retry=True, **kwargs):
    
    return DXHTTPRequest('/system/headers', input_params, always_retry=always_retry, **kwargs)
296147
function GetHeaders(additional_headers)
	{
		var ret_headers = {};
		// clone default headers into our return object (parsed)
		for(var key in headers)
		{
			ret_headers[key] = ParseStaches(headers[key]);
		}

		// add accept-language header based on our language
		ret_headers['Accept-Language'] = auth_obj.npLanguage + "," + languages.join(',');

		// add access token (if we have one)
		if (auth_obj.access_token)
		{
    		ret_headers['Authorization'] = 'Bearer ' + auth_obj.access_token;
		}

		// add additional headers (if supplied) (parsed)
		if (additional_headers) for(var key in additional_headers)
		{
			ret_headers[key] = ParseStaches(additional_headers[key]);
		}

		return ret_headers;
	}
95333
def list_user_luisaccounts(custom_headers:nil)
      response = list_user_luisaccounts_async(custom_headers:custom_headers).value!
      response.body unless response.nil?
    end
1356002
private static Result<?> decodeVariableHeader(ByteBuf buffer, MqttFixedHeader mqttFixedHeader) {
        switch (mqttFixedHeader.messageType()) {
            case CONNECT:
                return decodeConnectionVariableHeader(buffer);

            case CONNACK:
                return decodeConnAckVariableHeader(buffer);

            case SUBSCRIBE:
            case UNSUBSCRIBE:
            case SUBACK:
            case UNSUBACK:
            case PUBACK:
            case PUBREC:
            case PUBCOMP:
            case PUBREL:
                return decodeMessageIdVariableHeader(buffer);

            case PUBLISH:
                return decodePublishVariableHeader(buffer, mqttFixedHeader);

            case PINGREQ:
            case PINGRESP:
            case DISCONNECT:
                // Empty variable header
                return new Result<Object>(null, 0);
        }
        return new Result<Object>(null, 0); //should never reach here
    }
273988
def check_content_type(status, headers)
      headers.each { |key, value|
        ## There must be a <tt>Content-Type</tt>, except when the
        ## +Status+ is 1xx, 204 or 304, in which case there must be none
        ## given.
        if key.downcase == "content-type"
          assert("Content-Type header found in #{status} response, not allowed") {
            not Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include? status.to_i
          }
          return
        end
      }
      assert("No Content-Type header found") {
        Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include? status.to_i
      }
    end
1077276
def get_current_user(custom_headers:nil)
      response = get_current_user_async(custom_headers:custom_headers).value!
      response.body unless response.nil?
    end