For clean Markdown of any page, append .md to the page URL. For a complete documentation index, see https://api-doc-new.gideononline.com/gideon-api-1-0/diagnosis/llms.txt. For full documentation content, see https://api-doc-new.gideononline.com/gideon-api-1-0/diagnosis/llms-full.txt.

# /diagnosis/countries

GET https://api.gideononline.com/diagnosis/countries

Returns list of countries that can be used to chooce the country in which the patient acquired the disease. 

Generally the list of country names corresponds to accepted geographical and political designations. Certain territories, protectorates, etc are listed separately when their infectious disease status differs significantly from that of the ‘mother’ country. Thus Puerto Rico and Guam are processed as autonomous epidemiological entities by GIDEON. In contrast, newer countries or semi-autonomous regions (ie, Kosovo) will continue to appear in the app as part of the mother-nation (ie, Serbia).

The default < Worldwide > option is useful when generating a comprehensive list of all diseases associated with specific clinical findings.

The returned countries includes the "Bioterrorism Simulator" - designed for diagnosis and informatics relevant to the military and paramilitary use of human Infectious Disease agents. When "Bioterrorism Simulator" is selected as the "country", the resulting differential diagnosis list includes only diseases considered as potential agents of bioterrorism. Note that this list is not Bayesian; ie, all relevant diseases are assigned an equal ‘incidence’ when calculating probability.

Reference: https://api-doc-new.gideononline.com/gideon-api-1-0/diagnosis/diagnosis-countries

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: collection
  version: 1.0.0
paths:
  /diagnosis/countries:
    get:
      operationId: diagnosis-countries
      summary: /diagnosis/countries
      description: >-
        Returns list of countries that can be used to chooce the country in
        which the patient acquired the disease. 


        Generally the list of country names corresponds to accepted geographical
        and political designations. Certain territories, protectorates, etc are
        listed separately when their infectious disease status differs
        significantly from that of the ‘mother’ country. Thus Puerto Rico and
        Guam are processed as autonomous epidemiological entities by GIDEON. In
        contrast, newer countries or semi-autonomous regions (ie, Kosovo) will
        continue to appear in the app as part of the mother-nation (ie, Serbia).


        The default < Worldwide > option is useful when generating a
        comprehensive list of all diseases associated with specific clinical
        findings.


        The returned countries includes the "Bioterrorism Simulator" - designed
        for diagnosis and informatics relevant to the military and paramilitary
        use of human Infectious Disease agents. When "Bioterrorism Simulator" is
        selected as the "country", the resulting differential diagnosis list
        includes only diseases considered as potential agents of bioterrorism.
        Note that this list is not Bayesian; ie, all relevant diseases are
        assigned an equal ‘incidence’ when calculating probability.
      tags:
        - subpackage_diagnosis
      parameters:
        - name: Authorization
          in: header
          required: true
          schema:
            type: string
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/Diagnosis_/diagnosis/countries_Response_200
servers:
  - url: https://api.gideononline.com
  - url: https://api-test.gideononline.com
components:
  schemas:
    DiagnosisCountriesGetResponsesContentApplicationJsonSchemaDataItems:
      type: object
      properties:
        country:
          type: string
        country_code:
          type: string
      required:
        - country
        - country_code
      title: DiagnosisCountriesGetResponsesContentApplicationJsonSchemaDataItems
    Diagnosis_/diagnosis/countries_Response_200:
      type: object
      properties:
        data:
          type: array
          items:
            $ref: >-
              #/components/schemas/DiagnosisCountriesGetResponsesContentApplicationJsonSchemaDataItems
      required:
        - data
      title: Diagnosis_/diagnosis/countries_Response_200
  securitySchemes:
    apiKeyAuth:
      type: apiKey
      in: header
      name: Authorization

```

## SDK Code Examples

```python Diagnosis_/diagnosis/countries_example
import requests

url = "https://api.gideononline.com/diagnosis/countries"

headers = {"Authorization": "<apiKey>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript Diagnosis_/diagnosis/countries_example
const url = 'https://api.gideononline.com/diagnosis/countries';
const options = {method: 'GET', headers: {Authorization: '<apiKey>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Diagnosis_/diagnosis/countries_example
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.gideononline.com/diagnosis/countries"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "<apiKey>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Diagnosis_/diagnosis/countries_example
require 'uri'
require 'net/http'

url = URI("https://api.gideononline.com/diagnosis/countries")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = '<apiKey>'

response = http.request(request)
puts response.read_body
```

```java Diagnosis_/diagnosis/countries_example
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.gideononline.com/diagnosis/countries")
  .header("Authorization", "<apiKey>")
  .asString();
```

```php Diagnosis_/diagnosis/countries_example
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.gideononline.com/diagnosis/countries', [
  'headers' => [
    'Authorization' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Diagnosis_/diagnosis/countries_example
using RestSharp;

var client = new RestClient("https://api.gideononline.com/diagnosis/countries");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift Diagnosis_/diagnosis/countries_example
import Foundation

let headers = ["Authorization": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.gideononline.com/diagnosis/countries")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```