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

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

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/age_ratings")
  .header("Client-ID", "Client ID")
  .header("Authorization", "access_token")
  .header("Accept", "application/json")
  .body("fields category,checksum,content_descriptions,rating,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 "access_token", "Accept" to "application/json")
  .body("fields category,checksum,content_descriptions,rating,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,rating,rating_cover_url,synopsis;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("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' => 'access_token'})
request.body = 'fields category,checksum,content_descriptions,rating,rating_cover_url,synopsis;'
puts http.request(request).body

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

axios({
  url: "https://api.igdb.com/v4/age_rating_content_descriptions",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: access_token',
  },
  data: "fields category,checksum,description;"
})
  .then(response => {
      console.log(response.data);
  })
  .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", "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 "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("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' => 'access_token'})
request.body = 'fields category,checksum,description;'
puts http.request(request).body

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

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

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/characters")
  .header("Client-ID", "Client ID")
  .header("Authorization", "access_token")
  .header("Accept", "application/json")
  .body("fields akas,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 "access_token", "Accept" to "application/json")
  .body("fields akas,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,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("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' => 'access_token'})
request.body = 'fields akas,checksum,country_name,created_at,description,games,gender,mug_shot,name,slug,species,updated_at,url;'
puts http.request(request).body

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

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

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/alternative_names")
  .header("Client-ID", "Client ID")
  .header("Authorization", "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 "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("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' => 'access_token'})
request.body = 'fields checksum,comment,game,name;'
puts http.request(request).body

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: access_token' \
-H 'Accept: application/json'

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

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/artworks")
  .header("Client-ID", "Client ID")
  .header("Authorization", "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 "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("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' => 'access_token'})
request.body = 'fields alpha_channel,animated,checksum,game,height,image_id,url,width;'
puts http.request(request).body

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: access_token' \
-H 'Accept: application/json'

axios({
  url: "https://api.igdb.com/v4/character_mug_shots",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: access_token',
  },
  data: "fields alpha_channel,animated,checksum,height,image_id,url,width;"
})
  .then(response => {
      console.log(response.data);
  })
  .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", "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 "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("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' => 'access_token'})
request.body = 'fields alpha_channel,animated,checksum,height,image_id,url,width;'
puts http.request(request).body

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

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

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

val (request, response, result) = "https://api.igdb.com/v4/collections".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "access_token", "Accept" to "application/json")
  .body("fields checksum,created_at,games,name,slug,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 checksum,created_at,games,name,slug,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("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' => 'access_token'})
request.body = 'fields checksum,created_at,games,name,slug,updated_at,url;'
puts http.request(request).body

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

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

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

val (request, response, result) = "https://api.igdb.com/v4/companies".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "access_token", "Accept" to "application/json")
  .body("fields change_date,change_date_category,changed_company_id,checksum,country,created_at,description,developed,logo,name,parent,published,slug,start_date,start_date_category,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,changed_company_id,checksum,country,created_at,description,developed,logo,name,parent,published,slug,start_date,start_date_category,updated_at,url,websites;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("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' => 'access_token'})
request.body = 'fields change_date,change_date_category,changed_company_id,checksum,country,created_at,description,developed,logo,name,parent,published,slug,start_date,start_date_category,updated_at,url,websites;'
puts http.request(request).body

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

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

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

val (request, response, result) = "https://api.igdb.com/v4/company_websites".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "access_token", "Accept" to "application/json")
  .body("fields category,checksum,trusted,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,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("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' => 'access_token'})
request.body = 'fields category,checksum,trusted,url;'
puts http.request(request).body

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: access_token' \
-H 'Accept: application/json'

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

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/company_logos")
  .header("Client-ID", "Client ID")
  .header("Authorization", "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 "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("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' => 'access_token'})
request.body = 'fields alpha_channel,animated,checksum,height,image_id,url,width;'
puts http.request(request).body

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

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

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/covers")
  .header("Client-ID", "Client ID")
  .header("Authorization", "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/covers".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "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/covers")!
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("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' => 'access_token'})
request.body = 'fields alpha_channel,animated,checksum,game,height,image_id,url,width;'
puts http.request(request).body

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

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

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

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

let url = URL(string: "https://api.igdb.com/v4/franchises")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields checksum,created_at,games,name,slug,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("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/franchises'), {'Client-ID' => 'Client ID', 'Authorization' => 'access_token'})
request.body = 'fields checksum,created_at,games,name,slug,updated_at,url;'
puts http.request(request).body

curl 'https://api.igdb.com/v4/external_games' \
-d 'fields category,checksum,countries,created_at,game,media,name,platform,uid,updated_at,url,year;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: access_token' \
-H 'Accept: application/json'

axios({
  url: "https://api.igdb.com/v4/external_games",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: access_token',
  },
  data: "fields category,checksum,countries,created_at,game,media,name,platform,uid,updated_at,url,year;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/external_games")
  .header("Client-ID", "Client ID")
  .header("Authorization", "access_token")
  .header("Accept", "application/json")
  .body("fields category,checksum,countries,created_at,game,media,name,platform,uid,updated_at,url,year;")
  .asJson();

val (request, response, result) = "https://api.igdb.com/v4/external_games".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "access_token", "Accept" to "application/json")
  .body("fields category,checksum,countries,created_at,game,media,name,platform,uid,updated_at,url,year;").responseString()

let url = URL(string: "https://api.igdb.com/v4/external_games")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields category,checksum,countries,created_at,game,media,name,platform,uid,updated_at,url,year;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("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/external_games'), {'Client-ID' => 'Client ID', 'Authorization' => 'access_token'})
request.body = 'fields category,checksum,countries,created_at,game,media,name,platform,uid,updated_at,url,year;'
puts http.request(request).body

curl 'https://api.igdb.com/v4/games' \
-d 'fields age_ratings,aggregated_rating,aggregated_rating_count,alternative_names,artworks,bundles,category,checksum,collection,cover,created_at,dlcs,expansions,external_games,first_release_date,follows,franchise,franchises,game_engines,game_modes,genres,hypes,involved_companies,keywords,multiplayer_modes,name,parent_game,platforms,player_perspectives,rating,rating_count,release_dates,screenshots,similar_games,slug,standalone_expansions,status,storyline,summary,tags,themes,total_rating,total_rating_count,updated_at,url,version_parent,version_title,videos,websites;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: access_token' \
-H 'Accept: application/json'

axios({
  url: "https://api.igdb.com/v4/games",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: access_token',
  },
  data: "fields age_ratings,aggregated_rating,aggregated_rating_count,alternative_names,artworks,bundles,category,checksum,collection,cover,created_at,dlcs,expansions,external_games,first_release_date,follows,franchise,franchises,game_engines,game_modes,genres,hypes,involved_companies,keywords,multiplayer_modes,name,parent_game,platforms,player_perspectives,rating,rating_count,release_dates,screenshots,similar_games,slug,standalone_expansions,status,storyline,summary,tags,themes,total_rating,total_rating_count,updated_at,url,version_parent,version_title,videos,websites;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/games")
  .header("Client-ID", "Client ID")
  .header("Authorization", "access_token")
  .header("Accept", "application/json")
  .body("fields age_ratings,aggregated_rating,aggregated_rating_count,alternative_names,artworks,bundles,category,checksum,collection,cover,created_at,dlcs,expansions,external_games,first_release_date,follows,franchise,franchises,game_engines,game_modes,genres,hypes,involved_companies,keywords,multiplayer_modes,name,parent_game,platforms,player_perspectives,rating,rating_count,release_dates,screenshots,similar_games,slug,standalone_expansions,status,storyline,summary,tags,themes,total_rating,total_rating_count,updated_at,url,version_parent,version_title,videos,websites;")
  .asJson();

val (request, response, result) = "https://api.igdb.com/v4/games".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "access_token", "Accept" to "application/json")
  .body("fields age_ratings,aggregated_rating,aggregated_rating_count,alternative_names,artworks,bundles,category,checksum,collection,cover,created_at,dlcs,expansions,external_games,first_release_date,follows,franchise,franchises,game_engines,game_modes,genres,hypes,involved_companies,keywords,multiplayer_modes,name,parent_game,platforms,player_perspectives,rating,rating_count,release_dates,screenshots,similar_games,slug,standalone_expansions,status,storyline,summary,tags,themes,total_rating,total_rating_count,updated_at,url,version_parent,version_title,videos,websites;").responseString()

let url = URL(string: "https://api.igdb.com/v4/games")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields age_ratings,aggregated_rating,aggregated_rating_count,alternative_names,artworks,bundles,category,checksum,collection,cover,created_at,dlcs,expansions,external_games,first_release_date,follows,franchise,franchises,game_engines,game_modes,genres,hypes,involved_companies,keywords,multiplayer_modes,name,parent_game,platforms,player_perspectives,rating,rating_count,release_dates,screenshots,similar_games,slug,standalone_expansions,status,storyline,summary,tags,themes,total_rating,total_rating_count,updated_at,url,version_parent,version_title,videos,websites;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("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/games'), {'Client-ID' => 'Client ID', 'Authorization' => 'access_token'})
request.body = 'fields age_ratings,aggregated_rating,aggregated_rating_count,alternative_names,artworks,bundles,category,checksum,collection,cover,created_at,dlcs,expansions,external_games,first_release_date,follows,franchise,franchises,game_engines,game_modes,genres,hypes,involved_companies,keywords,multiplayer_modes,name,parent_game,platforms,player_perspectives,rating,rating_count,release_dates,screenshots,similar_games,slug,standalone_expansions,status,storyline,summary,tags,themes,total_rating,total_rating_count,updated_at,url,version_parent,version_title,videos,websites;'
puts http.request(request).body

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

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

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/game_engine_logos")
  .header("Client-ID", "Client ID")
  .header("Authorization", "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/game_engine_logos".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "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/game_engine_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("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/game_engine_logos'), {'Client-ID' => 'Client ID', 'Authorization' => 'access_token'})
request.body = 'fields alpha_channel,animated,checksum,height,image_id,url,width;'
puts http.request(request).body

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

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

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

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

let url = URL(string: "https://api.igdb.com/v4/game_modes")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields checksum,created_at,name,slug,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("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/game_modes'), {'Client-ID' => 'Client ID', 'Authorization' => 'access_token'})
request.body = 'fields checksum,created_at,name,slug,updated_at,url;'
puts http.request(request).body

curl 'https://api.igdb.com/v4/game_engines' \
-d 'fields checksum,companies,created_at,description,logo,name,platforms,slug,updated_at,url;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: access_token' \
-H 'Accept: application/json'

axios({
  url: "https://api.igdb.com/v4/game_engines",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: access_token',
  },
  data: "fields checksum,companies,created_at,description,logo,name,platforms,slug,updated_at,url;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

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

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

let url = URL(string: "https://api.igdb.com/v4/game_engines")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields checksum,companies,created_at,description,logo,name,platforms,slug,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("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/game_engines'), {'Client-ID' => 'Client ID', 'Authorization' => 'access_token'})
request.body = 'fields checksum,companies,created_at,description,logo,name,platforms,slug,updated_at,url;'
puts http.request(request).body

curl 'https://api.igdb.com/v4/game_versions' \
-d 'fields checksum,created_at,features,game,games,updated_at,url;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: access_token' \
-H 'Accept: application/json'

axios({
  url: "https://api.igdb.com/v4/game_versions",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: access_token',
  },
  data: "fields checksum,created_at,features,game,games,updated_at,url;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

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

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

let url = URL(string: "https://api.igdb.com/v4/game_versions")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields checksum,created_at,features,game,games,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("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/game_versions'), {'Client-ID' => 'Client ID', 'Authorization' => 'access_token'})
request.body = 'fields checksum,created_at,features,game,games,updated_at,url;'
puts http.request(request).body

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

axios({
  url: "https://api.igdb.com/v4/game_version_features",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: access_token',
  },
  data: "fields category,checksum,description,position,title,values;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

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

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

let url = URL(string: "https://api.igdb.com/v4/game_version_features")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields category,checksum,description,position,title,values;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("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/game_version_features'), {'Client-ID' => 'Client ID', 'Authorization' => 'access_token'})
request.body = 'fields category,checksum,description,position,title,values;'
puts http.request(request).body

curl 'https://api.igdb.com/v4/game_version_feature_values' \
-d 'fields checksum,game,game_feature,included_feature,note;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: access_token' \
-H 'Accept: application/json'

axios({
  url: "https://api.igdb.com/v4/game_version_feature_values",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: access_token',
  },
  data: "fields checksum,game,game_feature,included_feature,note;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

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

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

let url = URL(string: "https://api.igdb.com/v4/game_version_feature_values")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields checksum,game,game_feature,included_feature,note;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("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/game_version_feature_values'), {'Client-ID' => 'Client ID', 'Authorization' => 'access_token'})
request.body = 'fields checksum,game,game_feature,included_feature,note;'
puts http.request(request).body

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

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

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

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

let url = URL(string: "https://api.igdb.com/v4/genres")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields checksum,created_at,name,slug,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("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/genres'), {'Client-ID' => 'Client ID', 'Authorization' => 'access_token'})
request.body = 'fields checksum,created_at,name,slug,updated_at,url;'
puts http.request(request).body

curl 'https://api.igdb.com/v4/involved_companies' \
-d 'fields checksum,company,created_at,developer,game,porting,publisher,supporting,updated_at;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: access_token' \
-H 'Accept: application/json'

axios({
  url: "https://api.igdb.com/v4/involved_companies",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: access_token',
  },
  data: "fields checksum,company,created_at,developer,game,porting,publisher,supporting,updated_at;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/involved_companies")
  .header("Client-ID", "Client ID")
  .header("Authorization", "access_token")
  .header("Accept", "application/json")
  .body("fields checksum,company,created_at,developer,game,porting,publisher,supporting,updated_at;")
  .asJson();

val (request, response, result) = "https://api.igdb.com/v4/involved_companies".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "access_token", "Accept" to "application/json")
  .body("fields checksum,company,created_at,developer,game,porting,publisher,supporting,updated_at;").responseString()

let url = URL(string: "https://api.igdb.com/v4/involved_companies")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields checksum,company,created_at,developer,game,porting,publisher,supporting,updated_at;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("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/involved_companies'), {'Client-ID' => 'Client ID', 'Authorization' => 'access_token'})
request.body = 'fields checksum,company,created_at,developer,game,porting,publisher,supporting,updated_at;'
puts http.request(request).body

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

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

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

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

let url = URL(string: "https://api.igdb.com/v4/keywords")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields checksum,created_at,name,slug,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("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/keywords'), {'Client-ID' => 'Client ID', 'Authorization' => 'access_token'})
request.body = 'fields checksum,created_at,name,slug,updated_at,url;'
puts http.request(request).body

curl 'https://api.igdb.com/v4/platforms' \
-d 'fields abbreviation,alternative_name,category,checksum,created_at,generation,name,platform_family,platform_logo,slug,summary,updated_at,url,versions,websites;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: access_token' \
-H 'Accept: application/json'

axios({
  url: "https://api.igdb.com/v4/platforms",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: access_token',
  },
  data: "fields abbreviation,alternative_name,category,checksum,created_at,generation,name,platform_family,platform_logo,slug,summary,updated_at,url,versions,websites;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/platforms")
  .header("Client-ID", "Client ID")
  .header("Authorization", "access_token")
  .header("Accept", "application/json")
  .body("fields abbreviation,alternative_name,category,checksum,created_at,generation,name,platform_family,platform_logo,slug,summary,updated_at,url,versions,websites;")
  .asJson();

val (request, response, result) = "https://api.igdb.com/v4/platforms".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "access_token", "Accept" to "application/json")
  .body("fields abbreviation,alternative_name,category,checksum,created_at,generation,name,platform_family,platform_logo,slug,summary,updated_at,url,versions,websites;").responseString()

let url = URL(string: "https://api.igdb.com/v4/platforms")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields abbreviation,alternative_name,category,checksum,created_at,generation,name,platform_family,platform_logo,slug,summary,updated_at,url,versions,websites;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("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/platforms'), {'Client-ID' => 'Client ID', 'Authorization' => 'access_token'})
request.body = 'fields abbreviation,alternative_name,category,checksum,created_at,generation,name,platform_family,platform_logo,slug,summary,updated_at,url,versions,websites;'
puts http.request(request).body

curl 'https://api.igdb.com/v4/multiplayer_modes' \
-d 'fields campaigncoop,checksum,dropin,game,lancoop,offlinecoop,offlinecoopmax,offlinemax,onlinecoop,onlinecoopmax,onlinemax,platform,splitscreen,splitscreenonline;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: access_token' \
-H 'Accept: application/json'

axios({
  url: "https://api.igdb.com/v4/multiplayer_modes",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: access_token',
  },
  data: "fields campaigncoop,checksum,dropin,game,lancoop,offlinecoop,offlinecoopmax,offlinemax,onlinecoop,onlinecoopmax,onlinemax,platform,splitscreen,splitscreenonline;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/multiplayer_modes")
  .header("Client-ID", "Client ID")
  .header("Authorization", "access_token")
  .header("Accept", "application/json")
  .body("fields campaigncoop,checksum,dropin,game,lancoop,offlinecoop,offlinecoopmax,offlinemax,onlinecoop,onlinecoopmax,onlinemax,platform,splitscreen,splitscreenonline;")
  .asJson();

val (request, response, result) = "https://api.igdb.com/v4/multiplayer_modes".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "access_token", "Accept" to "application/json")
  .body("fields campaigncoop,checksum,dropin,game,lancoop,offlinecoop,offlinecoopmax,offlinemax,onlinecoop,onlinecoopmax,onlinemax,platform,splitscreen,splitscreenonline;").responseString()

let url = URL(string: "https://api.igdb.com/v4/multiplayer_modes")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields campaigncoop,checksum,dropin,game,lancoop,offlinecoop,offlinecoopmax,offlinemax,onlinecoop,onlinecoopmax,onlinemax,platform,splitscreen,splitscreenonline;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("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/multiplayer_modes'), {'Client-ID' => 'Client ID', 'Authorization' => 'access_token'})
request.body = 'fields campaigncoop,checksum,dropin,game,lancoop,offlinecoop,offlinecoopmax,offlinemax,onlinecoop,onlinecoopmax,onlinemax,platform,splitscreen,splitscreenonline;'
puts http.request(request).body

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

axios({
  url: "https://api.igdb.com/v4/platform_families",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: access_token',
  },
  data: "fields checksum,name,slug;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

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

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

let url = URL(string: "https://api.igdb.com/v4/platform_families")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields checksum,name,slug;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("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/platform_families'), {'Client-ID' => 'Client ID', 'Authorization' => 'access_token'})
request.body = 'fields checksum,name,slug;'
puts http.request(request).body

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

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

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

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

let url = URL(string: "https://api.igdb.com/v4/game_videos")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields checksum,game,name,video_id;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("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/game_videos'), {'Client-ID' => 'Client ID', 'Authorization' => 'access_token'})
request.body = 'fields checksum,game,name,video_id;'
puts http.request(request).body

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

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

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/platform_logos")
  .header("Client-ID", "Client ID")
  .header("Authorization", "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/platform_logos".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "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/platform_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("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/platform_logos'), {'Client-ID' => 'Client ID', 'Authorization' => 'access_token'})
request.body = 'fields alpha_channel,animated,checksum,height,image_id,url,width;'
puts http.request(request).body

curl 'https://api.igdb.com/v4/platform_version_release_dates' \
-d 'fields category,checksum,created_at,date,human,m,platform_version,region,updated_at,y;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: access_token' \
-H 'Accept: application/json'

axios({
  url: "https://api.igdb.com/v4/platform_version_release_dates",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: access_token',
  },
  data: "fields category,checksum,created_at,date,human,m,platform_version,region,updated_at,y;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/platform_version_release_dates")
  .header("Client-ID", "Client ID")
  .header("Authorization", "access_token")
  .header("Accept", "application/json")
  .body("fields category,checksum,created_at,date,human,m,platform_version,region,updated_at,y;")
  .asJson();

val (request, response, result) = "https://api.igdb.com/v4/platform_version_release_dates".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "access_token", "Accept" to "application/json")
  .body("fields category,checksum,created_at,date,human,m,platform_version,region,updated_at,y;").responseString()

let url = URL(string: "https://api.igdb.com/v4/platform_version_release_dates")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields category,checksum,created_at,date,human,m,platform_version,region,updated_at,y;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("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/platform_version_release_dates'), {'Client-ID' => 'Client ID', 'Authorization' => 'access_token'})
request.body = 'fields category,checksum,created_at,date,human,m,platform_version,region,updated_at,y;'
puts http.request(request).body

curl 'https://api.igdb.com/v4/platform_versions' \
-d 'fields checksum,companies,connectivity,cpu,graphics,main_manufacturer,media,memory,name,online,os,output,platform_logo,platform_version_release_dates,resolutions,slug,sound,storage,summary,url;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: access_token' \
-H 'Accept: application/json'

axios({
  url: "https://api.igdb.com/v4/platform_versions",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: access_token',
  },
  data: "fields checksum,companies,connectivity,cpu,graphics,main_manufacturer,media,memory,name,online,os,output,platform_logo,platform_version_release_dates,resolutions,slug,sound,storage,summary,url;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/platform_versions")
  .header("Client-ID", "Client ID")
  .header("Authorization", "access_token")
  .header("Accept", "application/json")
  .body("fields checksum,companies,connectivity,cpu,graphics,main_manufacturer,media,memory,name,online,os,output,platform_logo,platform_version_release_dates,resolutions,slug,sound,storage,summary,url;")
  .asJson();

val (request, response, result) = "https://api.igdb.com/v4/platform_versions".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "access_token", "Accept" to "application/json")
  .body("fields checksum,companies,connectivity,cpu,graphics,main_manufacturer,media,memory,name,online,os,output,platform_logo,platform_version_release_dates,resolutions,slug,sound,storage,summary,url;").responseString()

let url = URL(string: "https://api.igdb.com/v4/platform_versions")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields checksum,companies,connectivity,cpu,graphics,main_manufacturer,media,memory,name,online,os,output,platform_logo,platform_version_release_dates,resolutions,slug,sound,storage,summary,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("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/platform_versions'), {'Client-ID' => 'Client ID', 'Authorization' => 'access_token'})
request.body = 'fields checksum,companies,connectivity,cpu,graphics,main_manufacturer,media,memory,name,online,os,output,platform_logo,platform_version_release_dates,resolutions,slug,sound,storage,summary,url;'
puts http.request(request).body

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

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

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

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

let url = URL(string: "https://api.igdb.com/v4/platform_websites")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields category,checksum,trusted,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("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/platform_websites'), {'Client-ID' => 'Client ID', 'Authorization' => 'access_token'})
request.body = 'fields category,checksum,trusted,url;'
puts http.request(request).body

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

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

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

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

let url = URL(string: "https://api.igdb.com/v4/player_perspectives")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields checksum,created_at,name,slug,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("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/player_perspectives'), {'Client-ID' => 'Client ID', 'Authorization' => 'access_token'})
request.body = 'fields checksum,created_at,name,slug,updated_at,url;'
puts http.request(request).body

curl 'https://api.igdb.com/v4/release_dates' \
-d 'fields category,checksum,created_at,date,game,human,m,platform,region,updated_at,y;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: access_token' \
-H 'Accept: application/json'

axios({
  url: "https://api.igdb.com/v4/release_dates",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: access_token',
  },
  data: "fields category,checksum,created_at,date,game,human,m,platform,region,updated_at,y;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/release_dates")
  .header("Client-ID", "Client ID")
  .header("Authorization", "access_token")
  .header("Accept", "application/json")
  .body("fields category,checksum,created_at,date,game,human,m,platform,region,updated_at,y;")
  .asJson();

val (request, response, result) = "https://api.igdb.com/v4/release_dates".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "access_token", "Accept" to "application/json")
  .body("fields category,checksum,created_at,date,game,human,m,platform,region,updated_at,y;").responseString()

let url = URL(string: "https://api.igdb.com/v4/release_dates")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields category,checksum,created_at,date,game,human,m,platform,region,updated_at,y;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("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/release_dates'), {'Client-ID' => 'Client ID', 'Authorization' => 'access_token'})
request.body = 'fields category,checksum,created_at,date,game,human,m,platform,region,updated_at,y;'
puts http.request(request).body

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

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