curl 'https://api.igdb.com/v4/age_ratings' \
-d 'fields category,checksum,content_descriptions,organization,rating,rating_category,rating_content_descriptions,rating_cover_url,synopsis;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'

fetch(
  "https://api.igdb.com/v4/age_ratings",
  { method: 'POST',
    headers: {
      'Accept': 'application/json',
      'Client-ID': 'Client ID',
      'Authorization': 'Bearer access_token',
    },
    body: "fields category,checksum,content_descriptions,organization,rating,rating_category,rating_content_descriptions,rating_cover_url,synopsis;"
})
  .then(response => {
      console.log(response.json());
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/age_ratings")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields category,checksum,content_descriptions,organization,rating,rating_category,rating_content_descriptions,rating_cover_url,synopsis;")
  .asJson();

val (request, response, result) = "https://api.igdb.com/v4/age_ratings".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields category,checksum,content_descriptions,organization,rating,rating_category,rating_content_descriptions,rating_cover_url,synopsis;").responseString()

let url = URL(string: "https://api.igdb.com/v4/age_ratings")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields category,checksum,content_descriptions,organization,rating,rating_category,rating_content_descriptions,rating_cover_url,synopsis;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/age_ratings'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields category,checksum,content_descriptions,organization,rating,rating_category,rating_content_descriptions,rating_cover_url,synopsis;'
puts http.request(request).body

from requests import post
response = post('https://api.igdb.com/v4/age_ratings', **{'headers': {'Client-ID': 'Client ID', 'Authorization': 'Bearer access_token'},'data': 'fields category,checksum,content_descriptions,organization,rating,rating_category,rating_content_descriptions,rating_cover_url,synopsis;'})
print ("response: %s" % str(response.json()))

curl 'https://api.igdb.com/v4/age_rating_categories' \
-d 'fields checksum,created_at,organization,rating,updated_at;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'

fetch(
  "https://api.igdb.com/v4/age_rating_categories",
  { method: 'POST',
    headers: {
      'Accept': 'application/json',
      'Client-ID': 'Client ID',
      'Authorization': 'Bearer access_token',
    },
    body: "fields checksum,created_at,organization,rating,updated_at;"
})
  .then(response => {
      console.log(response.json());
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/age_rating_categories")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields checksum,created_at,organization,rating,updated_at;")
  .asJson();

val (request, response, result) = "https://api.igdb.com/v4/age_rating_categories".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields checksum,created_at,organization,rating,updated_at;").responseString()

let url = URL(string: "https://api.igdb.com/v4/age_rating_categories")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields checksum,created_at,organization,rating,updated_at;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/age_rating_categories'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields checksum,created_at,organization,rating,updated_at;'
puts http.request(request).body

from requests import post
response = post('https://api.igdb.com/v4/age_rating_categories', **{'headers': {'Client-ID': 'Client ID', 'Authorization': 'Bearer access_token'},'data': 'fields checksum,created_at,organization,rating,updated_at;'})
print ("response: %s" % str(response.json()))

curl 'https://api.igdb.com/v4/age_rating_content_descriptions' \
-d 'fields category,checksum,description;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'

fetch(
  "https://api.igdb.com/v4/age_rating_content_descriptions",
  { method: 'POST',
    headers: {
      'Accept': 'application/json',
      'Client-ID': 'Client ID',
      'Authorization': 'Bearer access_token',
    },
    body: "fields category,checksum,description;"
})
  .then(response => {
      console.log(response.json());
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/age_rating_content_descriptions")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields category,checksum,description;")
  .asJson();

val (request, response, result) = "https://api.igdb.com/v4/age_rating_content_descriptions".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields category,checksum,description;").responseString()

let url = URL(string: "https://api.igdb.com/v4/age_rating_content_descriptions")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields category,checksum,description;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/age_rating_content_descriptions'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields category,checksum,description;'
puts http.request(request).body

from requests import post
response = post('https://api.igdb.com/v4/age_rating_content_descriptions', **{'headers': {'Client-ID': 'Client ID', 'Authorization': 'Bearer access_token'},'data': 'fields category,checksum,description;'})
print ("response: %s" % str(response.json()))

curl 'https://api.igdb.com/v4/age_rating_content_descriptions_v2' \
-d 'fields checksum,created_at,description,organization,updated_at;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'

fetch(
  "https://api.igdb.com/v4/age_rating_content_descriptions_v2",
  { method: 'POST',
    headers: {
      'Accept': 'application/json',
      'Client-ID': 'Client ID',
      'Authorization': 'Bearer access_token',
    },
    body: "fields checksum,created_at,description,organization,updated_at;"
})
  .then(response => {
      console.log(response.json());
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/age_rating_content_descriptions_v2")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields checksum,created_at,description,organization,updated_at;")
  .asJson();

val (request, response, result) = "https://api.igdb.com/v4/age_rating_content_descriptions_v2".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields checksum,created_at,description,organization,updated_at;").responseString()

let url = URL(string: "https://api.igdb.com/v4/age_rating_content_descriptions_v2")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields checksum,created_at,description,organization,updated_at;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/age_rating_content_descriptions_v2'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields checksum,created_at,description,organization,updated_at;'
puts http.request(request).body

from requests import post
response = post('https://api.igdb.com/v4/age_rating_content_descriptions_v2', **{'headers': {'Client-ID': 'Client ID', 'Authorization': 'Bearer access_token'},'data': 'fields checksum,created_at,description,organization,updated_at;'})
print ("response: %s" % str(response.json()))

curl 'https://api.igdb.com/v4/age_rating_organizations' \
-d 'fields checksum,created_at,name,updated_at;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'

fetch(
  "https://api.igdb.com/v4/age_rating_organizations",
  { method: 'POST',
    headers: {
      'Accept': 'application/json',
      'Client-ID': 'Client ID',
      'Authorization': 'Bearer access_token',
    },
    body: "fields checksum,created_at,name,updated_at;"
})
  .then(response => {
      console.log(response.json());
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/age_rating_organizations")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields checksum,created_at,name,updated_at;")
  .asJson();

val (request, response, result) = "https://api.igdb.com/v4/age_rating_organizations".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields checksum,created_at,name,updated_at;").responseString()

let url = URL(string: "https://api.igdb.com/v4/age_rating_organizations")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields checksum,created_at,name,updated_at;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/age_rating_organizations'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields checksum,created_at,name,updated_at;'
puts http.request(request).body

from requests import post
response = post('https://api.igdb.com/v4/age_rating_organizations', **{'headers': {'Client-ID': 'Client ID', 'Authorization': 'Bearer access_token'},'data': 'fields checksum,created_at,name,updated_at;'})
print ("response: %s" % str(response.json()))

curl 'https://api.igdb.com/v4/alternative_names' \
-d 'fields checksum,comment,game,name;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'

fetch(
  "https://api.igdb.com/v4/alternative_names",
  { method: 'POST',
    headers: {
      'Accept': 'application/json',
      'Client-ID': 'Client ID',
      'Authorization': 'Bearer access_token',
    },
    body: "fields checksum,comment,game,name;"
})
  .then(response => {
      console.log(response.json());
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/alternative_names")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields checksum,comment,game,name;")
  .asJson();

val (request, response, result) = "https://api.igdb.com/v4/alternative_names".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields checksum,comment,game,name;").responseString()

let url = URL(string: "https://api.igdb.com/v4/alternative_names")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields checksum,comment,game,name;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/alternative_names'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields checksum,comment,game,name;'
puts http.request(request).body

from requests import post
response = post('https://api.igdb.com/v4/alternative_names', **{'headers': {'Client-ID': 'Client ID', 'Authorization': 'Bearer access_token'},'data': 'fields checksum,comment,game,name;'})
print ("response: %s" % str(response.json()))

curl 'https://api.igdb.com/v4/artworks' \
-d 'fields alpha_channel,animated,checksum,game,height,image_id,url,width;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'

fetch(
  "https://api.igdb.com/v4/artworks",
  { method: 'POST',
    headers: {
      'Accept': 'application/json',
      'Client-ID': 'Client ID',
      'Authorization': 'Bearer access_token',
    },
    body: "fields alpha_channel,animated,checksum,game,height,image_id,url,width;"
})
  .then(response => {
      console.log(response.json());
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/artworks")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields alpha_channel,animated,checksum,game,height,image_id,url,width;")
  .asJson();

val (request, response, result) = "https://api.igdb.com/v4/artworks".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields alpha_channel,animated,checksum,game,height,image_id,url,width;").responseString()

let url = URL(string: "https://api.igdb.com/v4/artworks")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields alpha_channel,animated,checksum,game,height,image_id,url,width;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/artworks'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields alpha_channel,animated,checksum,game,height,image_id,url,width;'
puts http.request(request).body

from requests import post
response = post('https://api.igdb.com/v4/artworks', **{'headers': {'Client-ID': 'Client ID', 'Authorization': 'Bearer access_token'},'data': 'fields alpha_channel,animated,checksum,game,height,image_id,url,width;'})
print ("response: %s" % str(response.json()))

curl 'https://api.igdb.com/v4/characters' \
-d 'fields akas,character_gender,character_species,checksum,country_name,created_at,description,games,gender,mug_shot,name,slug,species,updated_at,url;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'

fetch(
  "https://api.igdb.com/v4/characters",
  { method: 'POST',
    headers: {
      'Accept': 'application/json',
      'Client-ID': 'Client ID',
      'Authorization': 'Bearer access_token',
    },
    body: "fields akas,character_gender,character_species,checksum,country_name,created_at,description,games,gender,mug_shot,name,slug,species,updated_at,url;"
})
  .then(response => {
      console.log(response.json());
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/characters")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields akas,character_gender,character_species,checksum,country_name,created_at,description,games,gender,mug_shot,name,slug,species,updated_at,url;")
  .asJson();

val (request, response, result) = "https://api.igdb.com/v4/characters".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields akas,character_gender,character_species,checksum,country_name,created_at,description,games,gender,mug_shot,name,slug,species,updated_at,url;").responseString()

let url = URL(string: "https://api.igdb.com/v4/characters")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields akas,character_gender,character_species,checksum,country_name,created_at,description,games,gender,mug_shot,name,slug,species,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/characters'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields akas,character_gender,character_species,checksum,country_name,created_at,description,games,gender,mug_shot,name,slug,species,updated_at,url;'
puts http.request(request).body

from requests import post
response = post('https://api.igdb.com/v4/characters', **{'headers': {'Client-ID': 'Client ID', 'Authorization': 'Bearer access_token'},'data': 'fields akas,character_gender,character_species,checksum,country_name,created_at,description,games,gender,mug_shot,name,slug,species,updated_at,url;'})
print ("response: %s" % str(response.json()))

curl 'https://api.igdb.com/v4/character_genders' \
-d 'fields checksum,created_at,name,updated_at;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'

fetch(
  "https://api.igdb.com/v4/character_genders",
  { method: 'POST',
    headers: {
      'Accept': 'application/json',
      'Client-ID': 'Client ID',
      'Authorization': 'Bearer access_token',
    },
    body: "fields checksum,created_at,name,updated_at;"
})
  .then(response => {
      console.log(response.json());
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/character_genders")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields checksum,created_at,name,updated_at;")
  .asJson();

val (request, response, result) = "https://api.igdb.com/v4/character_genders".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields checksum,created_at,name,updated_at;").responseString()

let url = URL(string: "https://api.igdb.com/v4/character_genders")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields checksum,created_at,name,updated_at;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/character_genders'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields checksum,created_at,name,updated_at;'
puts http.request(request).body

from requests import post
response = post('https://api.igdb.com/v4/character_genders', **{'headers': {'Client-ID': 'Client ID', 'Authorization': 'Bearer access_token'},'data': 'fields checksum,created_at,name,updated_at;'})
print ("response: %s" % str(response.json()))

curl 'https://api.igdb.com/v4/character_mug_shots' \
-d 'fields alpha_channel,animated,checksum,height,image_id,url,width;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'

fetch(
  "https://api.igdb.com/v4/character_mug_shots",
  { method: 'POST',
    headers: {
      'Accept': 'application/json',
      'Client-ID': 'Client ID',
      'Authorization': 'Bearer access_token',
    },
    body: "fields alpha_channel,animated,checksum,height,image_id,url,width;"
})
  .then(response => {
      console.log(response.json());
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/character_mug_shots")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields alpha_channel,animated,checksum,height,image_id,url,width;")
  .asJson();

val (request, response, result) = "https://api.igdb.com/v4/character_mug_shots".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields alpha_channel,animated,checksum,height,image_id,url,width;").responseString()

let url = URL(string: "https://api.igdb.com/v4/character_mug_shots")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields alpha_channel,animated,checksum,height,image_id,url,width;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/character_mug_shots'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields alpha_channel,animated,checksum,height,image_id,url,width;'
puts http.request(request).body

from requests import post
response = post('https://api.igdb.com/v4/character_mug_shots', **{'headers': {'Client-ID': 'Client ID', 'Authorization': 'Bearer access_token'},'data': 'fields alpha_channel,animated,checksum,height,image_id,url,width;'})
print ("response: %s" % str(response.json()))

curl 'https://api.igdb.com/v4/character_species' \
-d 'fields checksum,created_at,name,updated_at;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'

fetch(
  "https://api.igdb.com/v4/character_species",
  { method: 'POST',
    headers: {
      'Accept': 'application/json',
      'Client-ID': 'Client ID',
      'Authorization': 'Bearer access_token',
    },
    body: "fields checksum,created_at,name,updated_at;"
})
  .then(response => {
      console.log(response.json());
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/character_species")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields checksum,created_at,name,updated_at;")
  .asJson();

val (request, response, result) = "https://api.igdb.com/v4/character_species".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields checksum,created_at,name,updated_at;").responseString()

let url = URL(string: "https://api.igdb.com/v4/character_species")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields checksum,created_at,name,updated_at;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/character_species'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields checksum,created_at,name,updated_at;'
puts http.request(request).body

from requests import post
response = post('https://api.igdb.com/v4/character_species', **{'headers': {'Client-ID': 'Client ID', 'Authorization': 'Bearer access_token'},'data': 'fields checksum,created_at,name,updated_at;'})
print ("response: %s" % str(response.json()))

curl 'https://api.igdb.com/v4/collections' \
-d 'fields as_child_relations,as_parent_relations,checksum,created_at,games,name,slug,type,updated_at,url;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'

fetch(
  "https://api.igdb.com/v4/collections",
  { method: 'POST',
    headers: {
      'Accept': 'application/json',
      'Client-ID': 'Client ID',
      'Authorization': 'Bearer access_token',
    },
    body: "fields as_child_relations,as_parent_relations,checksum,created_at,games,name,slug,type,updated_at,url;"
})
  .then(response => {
      console.log(response.json());
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/collections")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields as_child_relations,as_parent_relations,checksum,created_at,games,name,slug,type,updated_at,url;")
  .asJson();

val (request, response, result) = "https://api.igdb.com/v4/collections".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields as_child_relations,as_parent_relations,checksum,created_at,games,name,slug,type,updated_at,url;").responseString()

let url = URL(string: "https://api.igdb.com/v4/collections")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields as_child_relations,as_parent_relations,checksum,created_at,games,name,slug,type,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/collections'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields as_child_relations,as_parent_relations,checksum,created_at,games,name,slug,type,updated_at,url;'
puts http.request(request).body

from requests import post
response = post('https://api.igdb.com/v4/collections', **{'headers': {'Client-ID': 'Client ID', 'Authorization': 'Bearer access_token'},'data': 'fields as_child_relations,as_parent_relations,checksum,created_at,games,name,slug,type,updated_at,url;'})
print ("response: %s" % str(response.json()))

curl 'https://api.igdb.com/v4/collection_memberships' \
-d 'fields checksum,collection,created_at,game,type,updated_at;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'

fetch(
  "https://api.igdb.com/v4/collection_memberships",
  { method: 'POST',
    headers: {
      'Accept': 'application/json',
      'Client-ID': 'Client ID',
      'Authorization': 'Bearer access_token',
    },
    body: "fields checksum,collection,created_at,game,type,updated_at;"
})
  .then(response => {
      console.log(response.json());
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/collection_memberships")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields checksum,collection,created_at,game,type,updated_at;")
  .asJson();

val (request, response, result) = "https://api.igdb.com/v4/collection_memberships".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields checksum,collection,created_at,game,type,updated_at;").responseString()

let url = URL(string: "https://api.igdb.com/v4/collection_memberships")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields checksum,collection,created_at,game,type,updated_at;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/collection_memberships'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields checksum,collection,created_at,game,type,updated_at;'
puts http.request(request).body

from requests import post
response = post('https://api.igdb.com/v4/collection_memberships', **{'headers': {'Client-ID': 'Client ID', 'Authorization': 'Bearer access_token'},'data': 'fields checksum,collection,created_at,game,type,updated_at;'})
print ("response: %s" % str(response.json()))

curl 'https://api.igdb.com/v4/collection_membership_types' \
-d 'fields allowed_collection_type,checksum,created_at,description,name,updated_at;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'

fetch(
  "https://api.igdb.com/v4/collection_membership_types",
  { method: 'POST',
    headers: {
      'Accept': 'application/json',
      'Client-ID': 'Client ID',
      'Authorization': 'Bearer access_token',
    },
    body: "fields allowed_collection_type,checksum,created_at,description,name,updated_at;"
})
  .then(response => {
      console.log(response.json());
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/collection_membership_types")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields allowed_collection_type,checksum,created_at,description,name,updated_at;")
  .asJson();

val (request, response, result) = "https://api.igdb.com/v4/collection_membership_types".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields allowed_collection_type,checksum,created_at,description,name,updated_at;").responseString()

let url = URL(string: "https://api.igdb.com/v4/collection_membership_types")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields allowed_collection_type,checksum,created_at,description,name,updated_at;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/collection_membership_types'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields allowed_collection_type,checksum,created_at,description,name,updated_at;'
puts http.request(request).body

from requests import post
response = post('https://api.igdb.com/v4/collection_membership_types', **{'headers': {'Client-ID': 'Client ID', 'Authorization': 'Bearer access_token'},'data': 'fields allowed_collection_type,checksum,created_at,description,name,updated_at;'})
print ("response: %s" % str(response.json()))

curl 'https://api.igdb.com/v4/collection_relations' \
-d 'fields checksum,child_collection,created_at,parent_collection,type,updated_at;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'

fetch(
  "https://api.igdb.com/v4/collection_relations",
  { method: 'POST',
    headers: {
      'Accept': 'application/json',
      'Client-ID': 'Client ID',
      'Authorization': 'Bearer access_token',
    },
    body: "fields checksum,child_collection,created_at,parent_collection,type,updated_at;"
})
  .then(response => {
      console.log(response.json());
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/collection_relations")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields checksum,child_collection,created_at,parent_collection,type,updated_at;")
  .asJson();

val (request, response, result) = "https://api.igdb.com/v4/collection_relations".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields checksum,child_collection,created_at,parent_collection,type,updated_at;").responseString()

let url = URL(string: "https://api.igdb.com/v4/collection_relations")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields checksum,child_collection,created_at,parent_collection,type,updated_at;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/collection_relations'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields checksum,child_collection,created_at,parent_collection,type,updated_at;'
puts http.request(request).body

from requests import post
response = post('https://api.igdb.com/v4/collection_relations', **{'headers': {'Client-ID': 'Client ID', 'Authorization': 'Bearer access_token'},'data': 'fields checksum,child_collection,created_at,parent_collection,type,updated_at;'})
print ("response: %s" % str(response.json()))

curl 'https://api.igdb.com/v4/collection_relation_types' \
-d 'fields allowed_child_type,allowed_parent_type,checksum,created_at,description,name,updated_at;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'

fetch(
  "https://api.igdb.com/v4/collection_relation_types",
  { method: 'POST',
    headers: {
      'Accept': 'application/json',
      'Client-ID': 'Client ID',
      'Authorization': 'Bearer access_token',
    },
    body: "fields allowed_child_type,allowed_parent_type,checksum,created_at,description,name,updated_at;"
})
  .then(response => {
      console.log(response.json());
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/collection_relation_types")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields allowed_child_type,allowed_parent_type,checksum,created_at,description,name,updated_at;")
  .asJson();

val (request, response, result) = "https://api.igdb.com/v4/collection_relation_types".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields allowed_child_type,allowed_parent_type,checksum,created_at,description,name,updated_at;").responseString()

let url = URL(string: "https://api.igdb.com/v4/collection_relation_types")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields allowed_child_type,allowed_parent_type,checksum,created_at,description,name,updated_at;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/collection_relation_types'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields allowed_child_type,allowed_parent_type,checksum,created_at,description,name,updated_at;'
puts http.request(request).body

from requests import post
response = post('https://api.igdb.com/v4/collection_relation_types', **{'headers': {'Client-ID': 'Client ID', 'Authorization': 'Bearer access_token'},'data': 'fields allowed_child_type,allowed_parent_type,checksum,created_at,description,name,updated_at;'})
print ("response: %s" % str(response.json()))

curl 'https://api.igdb.com/v4/collection_types' \
-d 'fields checksum,created_at,description,name,updated_at;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'

fetch(
  "https://api.igdb.com/v4/collection_types",
  { method: 'POST',
    headers: {
      'Accept': 'application/json',
      'Client-ID': 'Client ID',
      'Authorization': 'Bearer access_token',
    },
    body: "fields checksum,created_at,description,name,updated_at;"
})
  .then(response => {
      console.log(response.json());
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/collection_types")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields checksum,created_at,description,name,updated_at;")
  .asJson();

val (request, response, result) = "https://api.igdb.com/v4/collection_types".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields checksum,created_at,description,name,updated_at;").responseString()

let url = URL(string: "https://api.igdb.com/v4/collection_types")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields checksum,created_at,description,name,updated_at;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/collection_types'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields checksum,created_at,description,name,updated_at;'
puts http.request(request).body

from requests import post
response = post('https://api.igdb.com/v4/collection_types', **{'headers': {'Client-ID': 'Client ID', 'Authorization': 'Bearer access_token'},'data': 'fields checksum,created_at,description,name,updated_at;'})
print ("response: %s" % str(response.json()))

curl 'https://api.igdb.com/v4/companies' \
-d 'fields change_date,change_date_category,change_date_format,changed_company_id,checksum,country,created_at,description,developed,logo,name,parent,published,slug,start_date,start_date_category,start_date_format,status,updated_at,url,websites;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'

fetch(
  "https://api.igdb.com/v4/companies",
  { method: 'POST',
    headers: {
      'Accept': 'application/json',
      'Client-ID': 'Client ID',
      'Authorization': 'Bearer access_token',
    },
    body: "fields change_date,change_date_category,change_date_format,changed_company_id,checksum,country,created_at,description,developed,logo,name,parent,published,slug,start_date,start_date_category,start_date_format,status,updated_at,url,websites;"
})
  .then(response => {
      console.log(response.json());
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/companies")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields change_date,change_date_category,change_date_format,changed_company_id,checksum,country,created_at,description,developed,logo,name,parent,published,slug,start_date,start_date_category,start_date_format,status,updated_at,url,websites;")
  .asJson();

val (request, response, result) = "https://api.igdb.com/v4/companies".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields change_date,change_date_category,change_date_format,changed_company_id,checksum,country,created_at,description,developed,logo,name,parent,published,slug,start_date,start_date_category,start_date_format,status,updated_at,url,websites;").responseString()

let url = URL(string: "https://api.igdb.com/v4/companies")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields change_date,change_date_category,change_date_format,changed_company_id,checksum,country,created_at,description,developed,logo,name,parent,published,slug,start_date,start_date_category,start_date_format,status,updated_at,url,websites;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/companies'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields change_date,change_date_category,change_date_format,changed_company_id,checksum,country,created_at,description,developed,logo,name,parent,published,slug,start_date,start_date_category,start_date_format,status,updated_at,url,websites;'
puts http.request(request).body

from requests import post
response = post('https://api.igdb.com/v4/companies', **{'headers': {'Client-ID': 'Client ID', 'Authorization': 'Bearer access_token'},'data': 'fields change_date,change_date_category,change_date_format,changed_company_id,checksum,country,created_at,description,developed,logo,name,parent,published,slug,start_date,start_date_category,start_date_format,status,updated_at,url,websites;'})
print ("response: %s" % str(response.json()))

curl 'https://api.igdb.com/v4/company_logos' \
-d 'fields alpha_channel,animated,checksum,height,image_id,url,width;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'

fetch(
  "https://api.igdb.com/v4/company_logos",
  { method: 'POST',
    headers: {
      'Accept': 'application/json',
      'Client-ID': 'Client ID',
      'Authorization': 'Bearer access_token',
    },
    body: "fields alpha_channel,animated,checksum,height,image_id,url,width;"
})
  .then(response => {
      console.log(response.json());
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/company_logos")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields alpha_channel,animated,checksum,height,image_id,url,width;")
  .asJson();

val (request, response, result) = "https://api.igdb.com/v4/company_logos".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields alpha_channel,animated,checksum,height,image_id,url,width;").responseString()

let url = URL(string: "https://api.igdb.com/v4/company_logos")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields alpha_channel,animated,checksum,height,image_id,url,width;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/company_logos'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields alpha_channel,animated,checksum,height,image_id,url,width;'
puts http.request(request).body

from requests import post
response = post('https://api.igdb.com/v4/company_logos', **{'headers': {'Client-ID': 'Client ID', 'Authorization': 'Bearer access_token'},'data': 'fields alpha_channel,animated,checksum,height,image_id,url,width;'})
print ("response: %s" % str(response.json()))

curl 'https://api.igdb.com/v4/company_statuses' \
-d 'fields checksum,created_at,name,updated_at;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'

fetch(
  "https://api.igdb.com/v4/company_statuses",
  { method: 'POST',
    headers: {
      'Accept': 'application/json',
      'Client-ID': 'Client ID',
      'Authorization': 'Bearer access_token',
    },
    body: "fields checksum,created_at,name,updated_at;"
})
  .then(response => {
      console.log(response.json());
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/company_statuses")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields checksum,created_at,name,updated_at;")
  .asJson();

val (request, response, result) = "https://api.igdb.com/v4/company_statuses".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields checksum,created_at,name,updated_at;").responseString()

let url = URL(string: "https://api.igdb.com/v4/company_statuses")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields checksum,created_at,name,updated_at;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/company_statuses'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields checksum,created_at,name,updated_at;'
puts http.request(request).body

from requests import post
response = post('https://api.igdb.com/v4/company_statuses', **{'headers': {'Client-ID': 'Client ID', 'Authorization': 'Bearer access_token'},'data': 'fields checksum,created_at,name,updated_at;'})
print ("response: %s" % str(response.json()))

curl 'https://api.igdb.com/v4/company_websites' \
-d 'fields category,checksum,trusted,type,url;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'

fetch(
  "https://api.igdb.com/v4/company_websites",
  { method: 'POST',
    headers: {
      'Accept': 'application/json',
      'Client-ID': 'Client ID',
      'Authorization': 'Bearer access_token',
    },
    body: "fields category,checksum,trusted,type,url;"
})
  .then(response => {
      console.log(response.json());
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/company_websites")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields category,checksum,trusted,type,url;")
  .asJson();

val (request, response, result) = "https://api.igdb.com/v4/company_websites".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields category,checksum,trusted,type,url;").responseString()

let url = URL(string: "https://api.igdb.com/v4/company_websites")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields category,checksum,trusted,type,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/company_websites'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields category,checksum,trusted,type,url;'
puts http.request(request).body

from requests import post
response = post('https://api.igdb.com/v4/company_websites', **{'headers': {'Client-ID': 'Client ID', 'Authorization': 'Bearer access_token'},'data': 'fields category,checksum,trusted,type,url;'})
print ("response: %s" % str(response.json()))

curl 'https://api.igdb.com/v4/covers' \
-d 'fields alpha_channel,animated,checksum,game,game_localization,height,image_id,url,width;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'

fetch(
  "https://api.igdb.com/v4/covers",
  { method: 'POST',
    headers: {
      'Accept': 'application/json',
      'Client-ID': 'Client ID',
      'Authorization': 'Bearer access_token',
    },
    body: "fields alpha_channel,animated,checksum,game,game_localization,height,image_id,url,width;"
})
  .then(response => {
      console.log(response.json());
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/covers")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields alpha_channel,animated,checksum,game,game_localization,height,image_id,url,width;")
  .asJson();

val (request, response, result) = "https://api.igdb.com/v4/covers".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields alpha_channel,animated,checksum,game,game_localization,height,image_id,url,width;").responseString()

let url = URL(string: "https://api.igdb.com/v4/covers")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields alpha_channel,animated,checksum,game,game_localization,height,image_id,url,width;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/covers'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields alpha_channel,animated,checksum,game,game_localization,height,image_id,url,width;'
puts http.request(request).body

from requests import post
response = post('https://api.igdb.com/v4/covers', **{'headers': {'Client-ID': 'Client ID', 'Authorization': 'Bearer access_token'},'data': 'fields alpha_channel,animated,checksum,game,game_localization,height,image_id,url,width;'})
print ("response: %s" % str(response.json()))

curl 'https://api.igdb.com/v4/date_formats' \
-d 'fields checksum,created_at,format,updated_at;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'

fetch(
  "https://api.igdb.com/v4/date_formats",
  { method: 'POST',
    headers: {
      'Accept': 'application/json',
      'Client-ID': 'Client ID',
      'Authorization': 'Bearer access_token',
    },
    body: "fields checksum,created_at,format,updated_at;"
})
  .then(response => {
      console.log(response.json());
  })
  .catch(err => {
      console.error(err);
  });