Gets the available application domains.

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

 @return [Array] operation results.
511290
def list_domains(custom_headers:nil)
      response = list_domains_async(custom_headers:custom_headers).value!
      response.body unless response.nil?
    end
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;
	}
104281
def _get_default_headers(cls):
        

        return {
            cls.HEADER_USER_AGENT: cls._USER_AGENT_BUNQ,
            cls.HEADER_REQUEST_ID: cls._generate_random_request_id(),
            cls.HEADER_GEOLOCATION: cls._GEOLOCATION_ZERO,
            cls.HEADER_LANGUAGE: cls._LANGUAGE_EN_US,
            cls.HEADER_REGION: cls._REGION_NL_NL,
            cls.HEADER_CACHE_CONTROL: cls._CACHE_CONTROL_NONE,
        }
643732
def get_requests(self):
        

        requests = self.derived_get_requests()

        for request in requests:
            request.url = URLHelper.remove_hash(request.url)

        return requests
1265750
def get_templates(options={})
      uri = build_uri("/accounts/#{acct_id}/templates")
      uri.query = URI.encode_www_form(options[:params]) if options[:params]

      http = initialize_net_http_ssl(uri)
      request = Net::HTTP::Get.new(uri.request_uri, headers({ 'Content-Type' => 'application/json' }))
      response = http.request(request)
      generate_log(request, response, uri)
      JSON.parse(response.body)
    end
1031144
function getDomainList(data) {
  var domains = [];

  _.each(data.emails, function(emailObject) {
    domains.push(emailObject.value.split('@')[1]);
  });

  return domains;
}
142351
def get_publishing_user(custom_headers:nil)
      response = get_publishing_user_async(custom_headers:custom_headers).value!
      response.body unless response.nil?
    end
408825
protected function _generateProxyRequestHeaders($as_string = FALSE)
    {
        $headers = array();
        $headers[] = 'Content-Type: ' . $this->_requestContentType;

        if ($this->_requestAuthorization) {
            $headers[] = 'Authorization: ' . $this->_requestAuthorization;
        }

        if ($this->_requestAccept) {
            $headers[] = 'Accept: ' . $this->_requestAccept;
        }

        if($as_string)
        {
            $data = "";
            foreach($headers as $value)
                if($value)
                    $data .= "$value\n";

            $headers = $data;
        }

        return $headers;
    }
200847
def list_endpoints(app_id, custom_headers:nil)
      response = list_endpoints_async(app_id, custom_headers:custom_headers).value!
      response.body unless response.nil?
    end
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)
        )
276683
def headers
      @headers ||= @raw_headers.inject({}) do |result, (key, value)|
        result.merge(key.split("-").map(&:capitalize).join("-") => value)
      end
    end
1187281
def index
      validate_arguments!
      domains = api.get_domains_v3_domain_cname(app)

      styled_header("#{app} Heroku Domain")
      heroku_domain = domains.detect { |d| d['kind'] == 'heroku' || d['kind'] == 'default' } # TODO: remove 'default' after API change
      if heroku_domain
        display heroku_domain['hostname']
      else
        output_with_bang "Not found"
      end

      display

      styled_header("#{app} Custom Domains")
      custom_domains = domains.select{ |d| d['kind'] == 'custom' }
      if custom_domains.length > 0
        display_table(custom_domains, ['hostname', 'cname'], ['Domain Name', 'DNS Target'])
      else
        display("#{app} has no custom domains.")
        display("Use `heroku domains:add DOMAIN` to add one.")
      end
    end
1245408
public static function get(array $customHeaders = []): BunqResponseUser
    {
        $apiClient = new ApiClient(static::getApiContext());
        $responseRaw = $apiClient->get(
            vsprintf(
                self::ENDPOINT_URL_READ,
                [static::determineUserId()]
            ),
            [],
            $customHeaders
        );

        return BunqResponseUser::castFromBunqResponse(
            static::fromJson($responseRaw)
        );
    }
1151706
def domains(self):
        
        json = self.request('/domains', method='GET')
        status = json.get('status')
        if status == 'OK':
            domains_json = json.get('domains', [])
            domains = [Domain.from_json(domain) for domain in domains_json]
            return domains
        else:
            message = json.get('message')
            raise DOPException('[%s]: %s' % (status, message))
1192206
def pre_process_method_headers(method, headers):
    '''
        
    '''
    method = method.lower()

    # Standard WSGI supported headers
    _wsgi_headers = ["content_length", "content_type", "query_string",
                     "remote_addr", "remote_host", "remote_user",
                     "request_method", "server_name", "server_port"]

    _transformed_headers = {}

    # For every header, replace - to _, prepend http_ if necessary and convert
    # to upper case.
    for header, value in headers.items():

        header = header.replace("-", "_")
        header = "http_{header}".format(
            header=header) if header.lower() not in _wsgi_headers else header
        _transformed_headers.update({header.upper(): value})

    return method, _transformed_headers
1249500
def list_all(custom_headers:nil)
      response = list_all_async(custom_headers:custom_headers).value!
      response.body unless response.nil?
    end
737975
def get_iterations(project_id, custom_headers:nil)
      response = get_iterations_async(project_id, custom_headers:custom_headers).value!
      response.body unless response.nil?
    end