Indicates which operations can be performed by the Power BI Resource
 Provider.

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

 @return [OperationList] operation results.
762778
def get_available_operations(custom_headers:nil)
      response = get_available_operations_async(custom_headers:custom_headers).value!
      response.body unless response.nil?
    end
1112186
function getOperationResponseHeaders(operation) {
    var headers = [];

    if (operation) {
        _.each(operation.responses, function(response, responseCode) {
            // Convert responseCode to a numeric value for sorting ("default" comes last)
            responseCode = parseInt(responseCode) || 999;

            _.each(response.headers, function(header, name) {
                // We only care about headers that have a default value defined
                if (header.default !== undefined) {
                    headers.push({
                        order: responseCode,
                        name: name.toLowerCase(),
                        value: header.default
                    });
                }
            });
        });
    }

    return _.sortBy(headers, 'order');
}
819883
def list(options = {})
      custom_params = []
      custom_params << use_named_parameter('dc', options[:dc]) if options[:dc]
      raw = send_get_request(@conn, ['/v1/session/list'], options, custom_params)
      JSON.parse(raw.body).map { |session| OpenStruct.new session }
    end
941658
def list(cls, invoice_id, custom_headers=None):
        

        if custom_headers is None:
            custom_headers = {}

        api_client = client.ApiClient(cls._get_api_context())
        endpoint_url = cls._ENDPOINT_URL_LISTING.format(
            cls._determine_user_id(), invoice_id)
        response_raw = api_client.get(endpoint_url, {}, custom_headers)

        return BunqResponseBytes.cast_from_bunq_response(
            client.BunqResponse(response_raw.body_bytes, response_raw.headers)
        )
770710
def _get_hash(self, name, operation, create=False):
        
        return self._get_by_type(name, operation, create, b'hash', {})
169255
def disabled(custom_headers:nil)
      response = disabled_async(custom_headers:custom_headers).value!
      response.body unless response.nil?
    end
1145023
def list_skus_for_new(custom_headers:nil)
      response = list_skus_for_new_async(custom_headers:custom_headers).value!
      response.body unless response.nil?
    end
1250571
def listing(callback=None, path=None, method=Method.GET, resource=None, tags=None, summary="List resources",
            middleware=None, default_limit=50, max_limit=None, use_wrapper=True):
    # type: (Callable, Path, Methods, Resource, Tags, str, List[Any], int, int) -> Operation
    
    op_type = WrappedListOperation if use_wrapper else ListOperation

    def inner(c):
        op = op_type(c, path or NoPath, method, resource, tags, summary, middleware,
                     default_limit=default_limit, max_limit=max_limit)
        op.responses.add(Response(HTTPStatus.OK, "Listing of resources", Listing))
        return op
    return inner(callback) if callback else inner
919163
def _get_operation_http(self):
        
        path = "operations/%s" % (self.name,)
        api_response = self.client._connection.api_request(method="GET", path=path)
        return json_format.ParseDict(api_response, operations_pb2.Operation())
1244156
def refresh_async(custom_headers:nil)
      # Send request
      promise = begin_refresh_async(custom_headers:custom_headers)

      promise = promise.then do |response|
        # Defining deserialization method.
        deserialize_method = lambda do |parsed_response|
          result_mapper = Azure::RecoveryServicesSiteRecovery::Mgmt::V2018_01_10::Models::VaultHealthDetails.mapper()
          parsed_response = @client.deserialize(result_mapper, parsed_response)
        end

        # Waiting for response.
        @client.get_long_running_operation_result(response, deserialize_method)
      end

      promise
    end
1082081
function getResponseHeaders (req) {
  let corsHeaders = {};
  if (req.swagger) {
    let headers = [];

    if (req.method !== "OPTIONS") {
      // This isn't a preflight request, so the operation's response headers take precedence over the OPTIONS headers
      headers = getOperationResponseHeaders(req.swagger.operation);
    }

    if (req.swagger.path) {
      // Regardless of whether this is a preflight request, append the OPTIONS response headers
      headers = headers.concat(getOperationResponseHeaders(req.swagger.path.options));
    }

    // Add the headers to the `corsHeaders` object.  First one wins.
    headers.forEach((header) => {
      if (corsHeaders[header.name] === undefined) {
        corsHeaders[header.name] = header.value;
      }
    });
  }

  return corsHeaders;
}
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;
	}
690458
def list(cls, params=None, custom_headers=None):
        

        if params is None:
            params = {}

        if custom_headers is None:
            custom_headers = {}

        api_client = client.ApiClient(cls._get_api_context())
        endpoint_url = cls._ENDPOINT_URL_LISTING
        response_raw = api_client.get(endpoint_url, params, custom_headers)

        return BunqResponseUserList.cast_from_bunq_response(
            cls._from_json_list(response_raw)
        )
976829
def list_cortana_endpoints(custom_headers:nil)
      response = list_cortana_endpoints_async(custom_headers:custom_headers).value!
      response.body unless response.nil?
    end
1082124
public Map<String, String> getCustomRequestHeaders() {
        if (customRequestHeaders == null) {
            return null;
        }
        return Collections.unmodifiableMap(customRequestHeaders);
    }
827480
def get_request_headers(self, *args, **kwds):
        
        if self.request_headers:
            return self._unpack_headers(self.request_headers)