CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/admin/analytics/count?stage=&queryName=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restv2/game/:apiKey/admin/analytics/count" {:query-params {:stage ""
                                                                                                    :queryName ""}})

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/admin/analytics/count?stage=&queryName="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/admin/analytics/count?stage=&queryName="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/admin/analytics/count?stage=&queryName=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/admin/analytics/count?stage=&queryName="

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

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

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

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

}

GET /baseUrl/restv2/game/:apiKey/admin/analytics/count?stage=&queryName= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restv2/game/:apiKey/admin/analytics/count?stage=&queryName=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/admin/analytics/count?stage=&queryName="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/admin/analytics/count?stage=&queryName=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restv2/game/:apiKey/admin/analytics/count?stage=&queryName=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/restv2/game/:apiKey/admin/analytics/count?stage=&queryName=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/analytics/count',
  params: {stage: '', queryName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/admin/analytics/count?stage=&queryName=';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/analytics/count?stage=&queryName=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/admin/analytics/count?stage=&queryName=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/admin/analytics/count?stage=&queryName=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/analytics/count',
  qs: {stage: '', queryName: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restv2/game/:apiKey/admin/analytics/count');

req.query({
  stage: '',
  queryName: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/analytics/count',
  params: {stage: '', queryName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/admin/analytics/count?stage=&queryName=';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/admin/analytics/count?stage=&queryName="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/admin/analytics/count?stage=&queryName=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/admin/analytics/count?stage=&queryName=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/restv2/game/:apiKey/admin/analytics/count?stage=&queryName=');

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/admin/analytics/count');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'stage' => '',
  'queryName' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/admin/analytics/count');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'stage' => '',
  'queryName' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/admin/analytics/count?stage=&queryName=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/admin/analytics/count?stage=&queryName=' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restv2/game/:apiKey/admin/analytics/count?stage=&queryName=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/admin/analytics/count"

querystring = {"stage":"","queryName":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/admin/analytics/count"

queryString <- list(
  stage = "",
  queryName = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/admin/analytics/count?stage=&queryName=")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/restv2/game/:apiKey/admin/analytics/count') do |req|
  req.params['stage'] = ''
  req.params['queryName'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/admin/analytics/count";

    let querystring = [
        ("stage", ""),
        ("queryName", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET '{{baseUrl}}/restv2/game/:apiKey/admin/analytics/count?stage=&queryName='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/restv2/game/:apiKey/admin/analytics/count?stage=&queryName='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/admin/analytics/count?stage=&queryName=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/admin/analytics/rollingRetention?stage=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restv2/game/:apiKey/admin/analytics/rollingRetention" {:query-params {:stage ""}})

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/admin/analytics/rollingRetention?stage="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/admin/analytics/rollingRetention?stage="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/admin/analytics/rollingRetention?stage=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/admin/analytics/rollingRetention?stage="

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

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

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

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

}

GET /baseUrl/restv2/game/:apiKey/admin/analytics/rollingRetention?stage= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restv2/game/:apiKey/admin/analytics/rollingRetention?stage=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/admin/analytics/rollingRetention?stage="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/admin/analytics/rollingRetention?stage=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restv2/game/:apiKey/admin/analytics/rollingRetention?stage=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/restv2/game/:apiKey/admin/analytics/rollingRetention?stage=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/analytics/rollingRetention',
  params: {stage: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/admin/analytics/rollingRetention?stage=';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/analytics/rollingRetention?stage=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/admin/analytics/rollingRetention?stage=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/admin/analytics/rollingRetention?stage=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/analytics/rollingRetention',
  qs: {stage: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restv2/game/:apiKey/admin/analytics/rollingRetention');

req.query({
  stage: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/analytics/rollingRetention',
  params: {stage: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/admin/analytics/rollingRetention?stage=';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/admin/analytics/rollingRetention?stage="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/admin/analytics/rollingRetention?stage=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/admin/analytics/rollingRetention?stage=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/restv2/game/:apiKey/admin/analytics/rollingRetention?stage=');

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/admin/analytics/rollingRetention');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'stage' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/admin/analytics/rollingRetention');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'stage' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/admin/analytics/rollingRetention?stage=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/admin/analytics/rollingRetention?stage=' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restv2/game/:apiKey/admin/analytics/rollingRetention?stage=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/admin/analytics/rollingRetention"

querystring = {"stage":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/admin/analytics/rollingRetention"

queryString <- list(stage = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/admin/analytics/rollingRetention?stage=")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/restv2/game/:apiKey/admin/analytics/rollingRetention') do |req|
  req.params['stage'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/admin/analytics/rollingRetention";

    let querystring = [
        ("stage", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET '{{baseUrl}}/restv2/game/:apiKey/admin/analytics/rollingRetention?stage='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/restv2/game/:apiKey/admin/analytics/rollingRetention?stage='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/admin/analytics/rollingRetention?stage=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/admin/analytics?stage=&dataType=&precision=&startDate=&endDate=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restv2/game/:apiKey/admin/analytics" {:query-params {:stage ""
                                                                                              :dataType ""
                                                                                              :precision ""
                                                                                              :startDate ""
                                                                                              :endDate ""}})

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/admin/analytics?stage=&dataType=&precision=&startDate=&endDate="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/admin/analytics?stage=&dataType=&precision=&startDate=&endDate="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/admin/analytics?stage=&dataType=&precision=&startDate=&endDate=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/admin/analytics?stage=&dataType=&precision=&startDate=&endDate="

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

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

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

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

}

GET /baseUrl/restv2/game/:apiKey/admin/analytics?stage=&dataType=&precision=&startDate=&endDate= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restv2/game/:apiKey/admin/analytics?stage=&dataType=&precision=&startDate=&endDate=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/admin/analytics?stage=&dataType=&precision=&startDate=&endDate="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/admin/analytics?stage=&dataType=&precision=&startDate=&endDate=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restv2/game/:apiKey/admin/analytics?stage=&dataType=&precision=&startDate=&endDate=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/restv2/game/:apiKey/admin/analytics?stage=&dataType=&precision=&startDate=&endDate=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/analytics',
  params: {stage: '', dataType: '', precision: '', startDate: '', endDate: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/admin/analytics?stage=&dataType=&precision=&startDate=&endDate=';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/analytics?stage=&dataType=&precision=&startDate=&endDate=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/admin/analytics?stage=&dataType=&precision=&startDate=&endDate=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/admin/analytics?stage=&dataType=&precision=&startDate=&endDate=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/analytics',
  qs: {stage: '', dataType: '', precision: '', startDate: '', endDate: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restv2/game/:apiKey/admin/analytics');

req.query({
  stage: '',
  dataType: '',
  precision: '',
  startDate: '',
  endDate: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/analytics',
  params: {stage: '', dataType: '', precision: '', startDate: '', endDate: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/admin/analytics?stage=&dataType=&precision=&startDate=&endDate=';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/admin/analytics?stage=&dataType=&precision=&startDate=&endDate="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/admin/analytics?stage=&dataType=&precision=&startDate=&endDate=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/admin/analytics?stage=&dataType=&precision=&startDate=&endDate=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/restv2/game/:apiKey/admin/analytics?stage=&dataType=&precision=&startDate=&endDate=');

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/admin/analytics');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'stage' => '',
  'dataType' => '',
  'precision' => '',
  'startDate' => '',
  'endDate' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/admin/analytics');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'stage' => '',
  'dataType' => '',
  'precision' => '',
  'startDate' => '',
  'endDate' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/admin/analytics?stage=&dataType=&precision=&startDate=&endDate=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/admin/analytics?stage=&dataType=&precision=&startDate=&endDate=' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restv2/game/:apiKey/admin/analytics?stage=&dataType=&precision=&startDate=&endDate=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/admin/analytics"

querystring = {"stage":"","dataType":"","precision":"","startDate":"","endDate":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/admin/analytics"

queryString <- list(
  stage = "",
  dataType = "",
  precision = "",
  startDate = "",
  endDate = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/admin/analytics?stage=&dataType=&precision=&startDate=&endDate=")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/restv2/game/:apiKey/admin/analytics') do |req|
  req.params['stage'] = ''
  req.params['dataType'] = ''
  req.params['precision'] = ''
  req.params['startDate'] = ''
  req.params['endDate'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/admin/analytics";

    let querystring = [
        ("stage", ""),
        ("dataType", ""),
        ("precision", ""),
        ("startDate", ""),
        ("endDate", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET '{{baseUrl}}/restv2/game/:apiKey/admin/analytics?stage=&dataType=&precision=&startDate=&endDate='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/restv2/game/:apiKey/admin/analytics?stage=&dataType=&precision=&startDate=&endDate='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/admin/analytics?stage=&dataType=&precision=&startDate=&endDate=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails")

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails"

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

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

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

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

}

GET /baseUrl/restv2/game/:apiKey/admin/billingDetails HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/admin/billingDetails',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails');

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restv2/game/:apiKey/admin/billingDetails")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/restv2/game/:apiKey/admin/billingDetails') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/restv2/game/:apiKey/admin/billingDetails

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/admin/billingDetails

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"building\": \"\",\n  \"city\": \"\",\n  \"companyName\": \"\",\n  \"country\": \"\",\n  \"email1\": \"\",\n  \"email2\": \"\",\n  \"email3\": \"\",\n  \"firstName1\": \"\",\n  \"firstName2\": \"\",\n  \"firstName3\": \"\",\n  \"lastName1\": \"\",\n  \"lastName2\": \"\",\n  \"lastName3\": \"\",\n  \"postcode\": \"\",\n  \"state\": \"\",\n  \"street\": \"\",\n  \"taxNumber\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails" {:content-type :json
                                                                                    :form-params {:building ""
                                                                                                  :city ""
                                                                                                  :companyName ""
                                                                                                  :country ""
                                                                                                  :email1 ""
                                                                                                  :email2 ""
                                                                                                  :email3 ""
                                                                                                  :firstName1 ""
                                                                                                  :firstName2 ""
                                                                                                  :firstName3 ""
                                                                                                  :lastName1 ""
                                                                                                  :lastName2 ""
                                                                                                  :lastName3 ""
                                                                                                  :postcode ""
                                                                                                  :state ""
                                                                                                  :street ""
                                                                                                  :taxNumber ""}})

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"building\": \"\",\n  \"city\": \"\",\n  \"companyName\": \"\",\n  \"country\": \"\",\n  \"email1\": \"\",\n  \"email2\": \"\",\n  \"email3\": \"\",\n  \"firstName1\": \"\",\n  \"firstName2\": \"\",\n  \"firstName3\": \"\",\n  \"lastName1\": \"\",\n  \"lastName2\": \"\",\n  \"lastName3\": \"\",\n  \"postcode\": \"\",\n  \"state\": \"\",\n  \"street\": \"\",\n  \"taxNumber\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails"),
    Content = new StringContent("{\n  \"building\": \"\",\n  \"city\": \"\",\n  \"companyName\": \"\",\n  \"country\": \"\",\n  \"email1\": \"\",\n  \"email2\": \"\",\n  \"email3\": \"\",\n  \"firstName1\": \"\",\n  \"firstName2\": \"\",\n  \"firstName3\": \"\",\n  \"lastName1\": \"\",\n  \"lastName2\": \"\",\n  \"lastName3\": \"\",\n  \"postcode\": \"\",\n  \"state\": \"\",\n  \"street\": \"\",\n  \"taxNumber\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"building\": \"\",\n  \"city\": \"\",\n  \"companyName\": \"\",\n  \"country\": \"\",\n  \"email1\": \"\",\n  \"email2\": \"\",\n  \"email3\": \"\",\n  \"firstName1\": \"\",\n  \"firstName2\": \"\",\n  \"firstName3\": \"\",\n  \"lastName1\": \"\",\n  \"lastName2\": \"\",\n  \"lastName3\": \"\",\n  \"postcode\": \"\",\n  \"state\": \"\",\n  \"street\": \"\",\n  \"taxNumber\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails"

	payload := strings.NewReader("{\n  \"building\": \"\",\n  \"city\": \"\",\n  \"companyName\": \"\",\n  \"country\": \"\",\n  \"email1\": \"\",\n  \"email2\": \"\",\n  \"email3\": \"\",\n  \"firstName1\": \"\",\n  \"firstName2\": \"\",\n  \"firstName3\": \"\",\n  \"lastName1\": \"\",\n  \"lastName2\": \"\",\n  \"lastName3\": \"\",\n  \"postcode\": \"\",\n  \"state\": \"\",\n  \"street\": \"\",\n  \"taxNumber\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

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

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

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

}

PUT /baseUrl/restv2/game/:apiKey/admin/billingDetails HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 305

{
  "building": "",
  "city": "",
  "companyName": "",
  "country": "",
  "email1": "",
  "email2": "",
  "email3": "",
  "firstName1": "",
  "firstName2": "",
  "firstName3": "",
  "lastName1": "",
  "lastName2": "",
  "lastName3": "",
  "postcode": "",
  "state": "",
  "street": "",
  "taxNumber": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"building\": \"\",\n  \"city\": \"\",\n  \"companyName\": \"\",\n  \"country\": \"\",\n  \"email1\": \"\",\n  \"email2\": \"\",\n  \"email3\": \"\",\n  \"firstName1\": \"\",\n  \"firstName2\": \"\",\n  \"firstName3\": \"\",\n  \"lastName1\": \"\",\n  \"lastName2\": \"\",\n  \"lastName3\": \"\",\n  \"postcode\": \"\",\n  \"state\": \"\",\n  \"street\": \"\",\n  \"taxNumber\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"building\": \"\",\n  \"city\": \"\",\n  \"companyName\": \"\",\n  \"country\": \"\",\n  \"email1\": \"\",\n  \"email2\": \"\",\n  \"email3\": \"\",\n  \"firstName1\": \"\",\n  \"firstName2\": \"\",\n  \"firstName3\": \"\",\n  \"lastName1\": \"\",\n  \"lastName2\": \"\",\n  \"lastName3\": \"\",\n  \"postcode\": \"\",\n  \"state\": \"\",\n  \"street\": \"\",\n  \"taxNumber\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"building\": \"\",\n  \"city\": \"\",\n  \"companyName\": \"\",\n  \"country\": \"\",\n  \"email1\": \"\",\n  \"email2\": \"\",\n  \"email3\": \"\",\n  \"firstName1\": \"\",\n  \"firstName2\": \"\",\n  \"firstName3\": \"\",\n  \"lastName1\": \"\",\n  \"lastName2\": \"\",\n  \"lastName3\": \"\",\n  \"postcode\": \"\",\n  \"state\": \"\",\n  \"street\": \"\",\n  \"taxNumber\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails")
  .header("content-type", "application/json")
  .body("{\n  \"building\": \"\",\n  \"city\": \"\",\n  \"companyName\": \"\",\n  \"country\": \"\",\n  \"email1\": \"\",\n  \"email2\": \"\",\n  \"email3\": \"\",\n  \"firstName1\": \"\",\n  \"firstName2\": \"\",\n  \"firstName3\": \"\",\n  \"lastName1\": \"\",\n  \"lastName2\": \"\",\n  \"lastName3\": \"\",\n  \"postcode\": \"\",\n  \"state\": \"\",\n  \"street\": \"\",\n  \"taxNumber\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  building: '',
  city: '',
  companyName: '',
  country: '',
  email1: '',
  email2: '',
  email3: '',
  firstName1: '',
  firstName2: '',
  firstName3: '',
  lastName1: '',
  lastName2: '',
  lastName3: '',
  postcode: '',
  state: '',
  street: '',
  taxNumber: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails',
  headers: {'content-type': 'application/json'},
  data: {
    building: '',
    city: '',
    companyName: '',
    country: '',
    email1: '',
    email2: '',
    email3: '',
    firstName1: '',
    firstName2: '',
    firstName3: '',
    lastName1: '',
    lastName2: '',
    lastName3: '',
    postcode: '',
    state: '',
    street: '',
    taxNumber: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"building":"","city":"","companyName":"","country":"","email1":"","email2":"","email3":"","firstName1":"","firstName2":"","firstName3":"","lastName1":"","lastName2":"","lastName3":"","postcode":"","state":"","street":"","taxNumber":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "building": "",\n  "city": "",\n  "companyName": "",\n  "country": "",\n  "email1": "",\n  "email2": "",\n  "email3": "",\n  "firstName1": "",\n  "firstName2": "",\n  "firstName3": "",\n  "lastName1": "",\n  "lastName2": "",\n  "lastName3": "",\n  "postcode": "",\n  "state": "",\n  "street": "",\n  "taxNumber": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"building\": \"\",\n  \"city\": \"\",\n  \"companyName\": \"\",\n  \"country\": \"\",\n  \"email1\": \"\",\n  \"email2\": \"\",\n  \"email3\": \"\",\n  \"firstName1\": \"\",\n  \"firstName2\": \"\",\n  \"firstName3\": \"\",\n  \"lastName1\": \"\",\n  \"lastName2\": \"\",\n  \"lastName3\": \"\",\n  \"postcode\": \"\",\n  \"state\": \"\",\n  \"street\": \"\",\n  \"taxNumber\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/admin/billingDetails',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  building: '',
  city: '',
  companyName: '',
  country: '',
  email1: '',
  email2: '',
  email3: '',
  firstName1: '',
  firstName2: '',
  firstName3: '',
  lastName1: '',
  lastName2: '',
  lastName3: '',
  postcode: '',
  state: '',
  street: '',
  taxNumber: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails',
  headers: {'content-type': 'application/json'},
  body: {
    building: '',
    city: '',
    companyName: '',
    country: '',
    email1: '',
    email2: '',
    email3: '',
    firstName1: '',
    firstName2: '',
    firstName3: '',
    lastName1: '',
    lastName2: '',
    lastName3: '',
    postcode: '',
    state: '',
    street: '',
    taxNumber: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  building: '',
  city: '',
  companyName: '',
  country: '',
  email1: '',
  email2: '',
  email3: '',
  firstName1: '',
  firstName2: '',
  firstName3: '',
  lastName1: '',
  lastName2: '',
  lastName3: '',
  postcode: '',
  state: '',
  street: '',
  taxNumber: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails',
  headers: {'content-type': 'application/json'},
  data: {
    building: '',
    city: '',
    companyName: '',
    country: '',
    email1: '',
    email2: '',
    email3: '',
    firstName1: '',
    firstName2: '',
    firstName3: '',
    lastName1: '',
    lastName2: '',
    lastName3: '',
    postcode: '',
    state: '',
    street: '',
    taxNumber: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"building":"","city":"","companyName":"","country":"","email1":"","email2":"","email3":"","firstName1":"","firstName2":"","firstName3":"","lastName1":"","lastName2":"","lastName3":"","postcode":"","state":"","street":"","taxNumber":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"building": @"",
                              @"city": @"",
                              @"companyName": @"",
                              @"country": @"",
                              @"email1": @"",
                              @"email2": @"",
                              @"email3": @"",
                              @"firstName1": @"",
                              @"firstName2": @"",
                              @"firstName3": @"",
                              @"lastName1": @"",
                              @"lastName2": @"",
                              @"lastName3": @"",
                              @"postcode": @"",
                              @"state": @"",
                              @"street": @"",
                              @"taxNumber": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"building\": \"\",\n  \"city\": \"\",\n  \"companyName\": \"\",\n  \"country\": \"\",\n  \"email1\": \"\",\n  \"email2\": \"\",\n  \"email3\": \"\",\n  \"firstName1\": \"\",\n  \"firstName2\": \"\",\n  \"firstName3\": \"\",\n  \"lastName1\": \"\",\n  \"lastName2\": \"\",\n  \"lastName3\": \"\",\n  \"postcode\": \"\",\n  \"state\": \"\",\n  \"street\": \"\",\n  \"taxNumber\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'building' => '',
    'city' => '',
    'companyName' => '',
    'country' => '',
    'email1' => '',
    'email2' => '',
    'email3' => '',
    'firstName1' => '',
    'firstName2' => '',
    'firstName3' => '',
    'lastName1' => '',
    'lastName2' => '',
    'lastName3' => '',
    'postcode' => '',
    'state' => '',
    'street' => '',
    'taxNumber' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails', [
  'body' => '{
  "building": "",
  "city": "",
  "companyName": "",
  "country": "",
  "email1": "",
  "email2": "",
  "email3": "",
  "firstName1": "",
  "firstName2": "",
  "firstName3": "",
  "lastName1": "",
  "lastName2": "",
  "lastName3": "",
  "postcode": "",
  "state": "",
  "street": "",
  "taxNumber": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'building' => '',
  'city' => '',
  'companyName' => '',
  'country' => '',
  'email1' => '',
  'email2' => '',
  'email3' => '',
  'firstName1' => '',
  'firstName2' => '',
  'firstName3' => '',
  'lastName1' => '',
  'lastName2' => '',
  'lastName3' => '',
  'postcode' => '',
  'state' => '',
  'street' => '',
  'taxNumber' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'building' => '',
  'city' => '',
  'companyName' => '',
  'country' => '',
  'email1' => '',
  'email2' => '',
  'email3' => '',
  'firstName1' => '',
  'firstName2' => '',
  'firstName3' => '',
  'lastName1' => '',
  'lastName2' => '',
  'lastName3' => '',
  'postcode' => '',
  'state' => '',
  'street' => '',
  'taxNumber' => ''
]));
$request->setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "building": "",
  "city": "",
  "companyName": "",
  "country": "",
  "email1": "",
  "email2": "",
  "email3": "",
  "firstName1": "",
  "firstName2": "",
  "firstName3": "",
  "lastName1": "",
  "lastName2": "",
  "lastName3": "",
  "postcode": "",
  "state": "",
  "street": "",
  "taxNumber": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "building": "",
  "city": "",
  "companyName": "",
  "country": "",
  "email1": "",
  "email2": "",
  "email3": "",
  "firstName1": "",
  "firstName2": "",
  "firstName3": "",
  "lastName1": "",
  "lastName2": "",
  "lastName3": "",
  "postcode": "",
  "state": "",
  "street": "",
  "taxNumber": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"building\": \"\",\n  \"city\": \"\",\n  \"companyName\": \"\",\n  \"country\": \"\",\n  \"email1\": \"\",\n  \"email2\": \"\",\n  \"email3\": \"\",\n  \"firstName1\": \"\",\n  \"firstName2\": \"\",\n  \"firstName3\": \"\",\n  \"lastName1\": \"\",\n  \"lastName2\": \"\",\n  \"lastName3\": \"\",\n  \"postcode\": \"\",\n  \"state\": \"\",\n  \"street\": \"\",\n  \"taxNumber\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/restv2/game/:apiKey/admin/billingDetails", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails"

payload = {
    "building": "",
    "city": "",
    "companyName": "",
    "country": "",
    "email1": "",
    "email2": "",
    "email3": "",
    "firstName1": "",
    "firstName2": "",
    "firstName3": "",
    "lastName1": "",
    "lastName2": "",
    "lastName3": "",
    "postcode": "",
    "state": "",
    "street": "",
    "taxNumber": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails"

payload <- "{\n  \"building\": \"\",\n  \"city\": \"\",\n  \"companyName\": \"\",\n  \"country\": \"\",\n  \"email1\": \"\",\n  \"email2\": \"\",\n  \"email3\": \"\",\n  \"firstName1\": \"\",\n  \"firstName2\": \"\",\n  \"firstName3\": \"\",\n  \"lastName1\": \"\",\n  \"lastName2\": \"\",\n  \"lastName3\": \"\",\n  \"postcode\": \"\",\n  \"state\": \"\",\n  \"street\": \"\",\n  \"taxNumber\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"building\": \"\",\n  \"city\": \"\",\n  \"companyName\": \"\",\n  \"country\": \"\",\n  \"email1\": \"\",\n  \"email2\": \"\",\n  \"email3\": \"\",\n  \"firstName1\": \"\",\n  \"firstName2\": \"\",\n  \"firstName3\": \"\",\n  \"lastName1\": \"\",\n  \"lastName2\": \"\",\n  \"lastName3\": \"\",\n  \"postcode\": \"\",\n  \"state\": \"\",\n  \"street\": \"\",\n  \"taxNumber\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/restv2/game/:apiKey/admin/billingDetails') do |req|
  req.body = "{\n  \"building\": \"\",\n  \"city\": \"\",\n  \"companyName\": \"\",\n  \"country\": \"\",\n  \"email1\": \"\",\n  \"email2\": \"\",\n  \"email3\": \"\",\n  \"firstName1\": \"\",\n  \"firstName2\": \"\",\n  \"firstName3\": \"\",\n  \"lastName1\": \"\",\n  \"lastName2\": \"\",\n  \"lastName3\": \"\",\n  \"postcode\": \"\",\n  \"state\": \"\",\n  \"street\": \"\",\n  \"taxNumber\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails";

    let payload = json!({
        "building": "",
        "city": "",
        "companyName": "",
        "country": "",
        "email1": "",
        "email2": "",
        "email3": "",
        "firstName1": "",
        "firstName2": "",
        "firstName3": "",
        "lastName1": "",
        "lastName2": "",
        "lastName3": "",
        "postcode": "",
        "state": "",
        "street": "",
        "taxNumber": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "building": "",
  "city": "",
  "companyName": "",
  "country": "",
  "email1": "",
  "email2": "",
  "email3": "",
  "firstName1": "",
  "firstName2": "",
  "firstName3": "",
  "lastName1": "",
  "lastName2": "",
  "lastName3": "",
  "postcode": "",
  "state": "",
  "street": "",
  "taxNumber": ""
}' |  \
  http PUT {{baseUrl}}/restv2/game/:apiKey/admin/billingDetails \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "building": "",\n  "city": "",\n  "companyName": "",\n  "country": "",\n  "email1": "",\n  "email2": "",\n  "email3": "",\n  "firstName1": "",\n  "firstName2": "",\n  "firstName3": "",\n  "lastName1": "",\n  "lastName2": "",\n  "lastName3": "",\n  "postcode": "",\n  "state": "",\n  "street": "",\n  "taxNumber": ""\n}' \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/admin/billingDetails

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "building": "",
  "city": "",
  "companyName": "",
  "country": "",
  "email1": "",
  "email2": "",
  "email3": "",
  "firstName1": "",
  "firstName2": "",
  "firstName3": "",
  "lastName1": "",
  "lastName2": "",
  "lastName3": "",
  "postcode": "",
  "state": "",
  "street": "",
  "taxNumber": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/admin/billingDetails")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret")

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret"

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

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

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

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

}

POST /baseUrl/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret');

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret")

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

request = Net::HTTP::Post.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST '{{baseUrl}}/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret'

wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/config/~credentials/:credentialName/resetSecret")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/manage/experiments");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"active\": false,\n  \"changedFieldsAndInitialValues\": {},\n  \"complete\": false,\n  \"config\": {\n    \"playerMongoQuery\": \"\",\n    \"playerQuery\": \"\",\n    \"variants\": \"\"\n  },\n  \"endDate\": \"\",\n  \"id\": 0,\n  \"measurements\": \"\",\n  \"measurementsEsQuery\": \"\",\n  \"name\": \"\",\n  \"percentHash\": \"\",\n  \"publishedStages\": [],\n  \"startDate\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/restv2/game/:apiKey/manage/experiments" {:content-type :json
                                                                                   :form-params {:active false
                                                                                                 :changedFieldsAndInitialValues {}
                                                                                                 :complete false
                                                                                                 :config {:playerMongoQuery ""
                                                                                                          :playerQuery ""
                                                                                                          :variants ""}
                                                                                                 :endDate ""
                                                                                                 :id 0
                                                                                                 :measurements ""
                                                                                                 :measurementsEsQuery ""
                                                                                                 :name ""
                                                                                                 :percentHash ""
                                                                                                 :publishedStages []
                                                                                                 :startDate ""}})

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/manage/experiments"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"active\": false,\n  \"changedFieldsAndInitialValues\": {},\n  \"complete\": false,\n  \"config\": {\n    \"playerMongoQuery\": \"\",\n    \"playerQuery\": \"\",\n    \"variants\": \"\"\n  },\n  \"endDate\": \"\",\n  \"id\": 0,\n  \"measurements\": \"\",\n  \"measurementsEsQuery\": \"\",\n  \"name\": \"\",\n  \"percentHash\": \"\",\n  \"publishedStages\": [],\n  \"startDate\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/manage/experiments"),
    Content = new StringContent("{\n  \"active\": false,\n  \"changedFieldsAndInitialValues\": {},\n  \"complete\": false,\n  \"config\": {\n    \"playerMongoQuery\": \"\",\n    \"playerQuery\": \"\",\n    \"variants\": \"\"\n  },\n  \"endDate\": \"\",\n  \"id\": 0,\n  \"measurements\": \"\",\n  \"measurementsEsQuery\": \"\",\n  \"name\": \"\",\n  \"percentHash\": \"\",\n  \"publishedStages\": [],\n  \"startDate\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/manage/experiments");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"active\": false,\n  \"changedFieldsAndInitialValues\": {},\n  \"complete\": false,\n  \"config\": {\n    \"playerMongoQuery\": \"\",\n    \"playerQuery\": \"\",\n    \"variants\": \"\"\n  },\n  \"endDate\": \"\",\n  \"id\": 0,\n  \"measurements\": \"\",\n  \"measurementsEsQuery\": \"\",\n  \"name\": \"\",\n  \"percentHash\": \"\",\n  \"publishedStages\": [],\n  \"startDate\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/manage/experiments"

	payload := strings.NewReader("{\n  \"active\": false,\n  \"changedFieldsAndInitialValues\": {},\n  \"complete\": false,\n  \"config\": {\n    \"playerMongoQuery\": \"\",\n    \"playerQuery\": \"\",\n    \"variants\": \"\"\n  },\n  \"endDate\": \"\",\n  \"id\": 0,\n  \"measurements\": \"\",\n  \"measurementsEsQuery\": \"\",\n  \"name\": \"\",\n  \"percentHash\": \"\",\n  \"publishedStages\": [],\n  \"startDate\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/restv2/game/:apiKey/manage/experiments HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 328

{
  "active": false,
  "changedFieldsAndInitialValues": {},
  "complete": false,
  "config": {
    "playerMongoQuery": "",
    "playerQuery": "",
    "variants": ""
  },
  "endDate": "",
  "id": 0,
  "measurements": "",
  "measurementsEsQuery": "",
  "name": "",
  "percentHash": "",
  "publishedStages": [],
  "startDate": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/restv2/game/:apiKey/manage/experiments")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"active\": false,\n  \"changedFieldsAndInitialValues\": {},\n  \"complete\": false,\n  \"config\": {\n    \"playerMongoQuery\": \"\",\n    \"playerQuery\": \"\",\n    \"variants\": \"\"\n  },\n  \"endDate\": \"\",\n  \"id\": 0,\n  \"measurements\": \"\",\n  \"measurementsEsQuery\": \"\",\n  \"name\": \"\",\n  \"percentHash\": \"\",\n  \"publishedStages\": [],\n  \"startDate\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/manage/experiments"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"active\": false,\n  \"changedFieldsAndInitialValues\": {},\n  \"complete\": false,\n  \"config\": {\n    \"playerMongoQuery\": \"\",\n    \"playerQuery\": \"\",\n    \"variants\": \"\"\n  },\n  \"endDate\": \"\",\n  \"id\": 0,\n  \"measurements\": \"\",\n  \"measurementsEsQuery\": \"\",\n  \"name\": \"\",\n  \"percentHash\": \"\",\n  \"publishedStages\": [],\n  \"startDate\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"active\": false,\n  \"changedFieldsAndInitialValues\": {},\n  \"complete\": false,\n  \"config\": {\n    \"playerMongoQuery\": \"\",\n    \"playerQuery\": \"\",\n    \"variants\": \"\"\n  },\n  \"endDate\": \"\",\n  \"id\": 0,\n  \"measurements\": \"\",\n  \"measurementsEsQuery\": \"\",\n  \"name\": \"\",\n  \"percentHash\": \"\",\n  \"publishedStages\": [],\n  \"startDate\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/experiments")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/restv2/game/:apiKey/manage/experiments")
  .header("content-type", "application/json")
  .body("{\n  \"active\": false,\n  \"changedFieldsAndInitialValues\": {},\n  \"complete\": false,\n  \"config\": {\n    \"playerMongoQuery\": \"\",\n    \"playerQuery\": \"\",\n    \"variants\": \"\"\n  },\n  \"endDate\": \"\",\n  \"id\": 0,\n  \"measurements\": \"\",\n  \"measurementsEsQuery\": \"\",\n  \"name\": \"\",\n  \"percentHash\": \"\",\n  \"publishedStages\": [],\n  \"startDate\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  active: false,
  changedFieldsAndInitialValues: {},
  complete: false,
  config: {
    playerMongoQuery: '',
    playerQuery: '',
    variants: ''
  },
  endDate: '',
  id: 0,
  measurements: '',
  measurementsEsQuery: '',
  name: '',
  percentHash: '',
  publishedStages: [],
  startDate: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/restv2/game/:apiKey/manage/experiments');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/experiments',
  headers: {'content-type': 'application/json'},
  data: {
    active: false,
    changedFieldsAndInitialValues: {},
    complete: false,
    config: {playerMongoQuery: '', playerQuery: '', variants: ''},
    endDate: '',
    id: 0,
    measurements: '',
    measurementsEsQuery: '',
    name: '',
    percentHash: '',
    publishedStages: [],
    startDate: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/experiments';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"active":false,"changedFieldsAndInitialValues":{},"complete":false,"config":{"playerMongoQuery":"","playerQuery":"","variants":""},"endDate":"","id":0,"measurements":"","measurementsEsQuery":"","name":"","percentHash":"","publishedStages":[],"startDate":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/experiments',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "active": false,\n  "changedFieldsAndInitialValues": {},\n  "complete": false,\n  "config": {\n    "playerMongoQuery": "",\n    "playerQuery": "",\n    "variants": ""\n  },\n  "endDate": "",\n  "id": 0,\n  "measurements": "",\n  "measurementsEsQuery": "",\n  "name": "",\n  "percentHash": "",\n  "publishedStages": [],\n  "startDate": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"active\": false,\n  \"changedFieldsAndInitialValues\": {},\n  \"complete\": false,\n  \"config\": {\n    \"playerMongoQuery\": \"\",\n    \"playerQuery\": \"\",\n    \"variants\": \"\"\n  },\n  \"endDate\": \"\",\n  \"id\": 0,\n  \"measurements\": \"\",\n  \"measurementsEsQuery\": \"\",\n  \"name\": \"\",\n  \"percentHash\": \"\",\n  \"publishedStages\": [],\n  \"startDate\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/experiments")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/manage/experiments',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  active: false,
  changedFieldsAndInitialValues: {},
  complete: false,
  config: {playerMongoQuery: '', playerQuery: '', variants: ''},
  endDate: '',
  id: 0,
  measurements: '',
  measurementsEsQuery: '',
  name: '',
  percentHash: '',
  publishedStages: [],
  startDate: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/experiments',
  headers: {'content-type': 'application/json'},
  body: {
    active: false,
    changedFieldsAndInitialValues: {},
    complete: false,
    config: {playerMongoQuery: '', playerQuery: '', variants: ''},
    endDate: '',
    id: 0,
    measurements: '',
    measurementsEsQuery: '',
    name: '',
    percentHash: '',
    publishedStages: [],
    startDate: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/restv2/game/:apiKey/manage/experiments');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  active: false,
  changedFieldsAndInitialValues: {},
  complete: false,
  config: {
    playerMongoQuery: '',
    playerQuery: '',
    variants: ''
  },
  endDate: '',
  id: 0,
  measurements: '',
  measurementsEsQuery: '',
  name: '',
  percentHash: '',
  publishedStages: [],
  startDate: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/experiments',
  headers: {'content-type': 'application/json'},
  data: {
    active: false,
    changedFieldsAndInitialValues: {},
    complete: false,
    config: {playerMongoQuery: '', playerQuery: '', variants: ''},
    endDate: '',
    id: 0,
    measurements: '',
    measurementsEsQuery: '',
    name: '',
    percentHash: '',
    publishedStages: [],
    startDate: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/experiments';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"active":false,"changedFieldsAndInitialValues":{},"complete":false,"config":{"playerMongoQuery":"","playerQuery":"","variants":""},"endDate":"","id":0,"measurements":"","measurementsEsQuery":"","name":"","percentHash":"","publishedStages":[],"startDate":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"active": @NO,
                              @"changedFieldsAndInitialValues": @{  },
                              @"complete": @NO,
                              @"config": @{ @"playerMongoQuery": @"", @"playerQuery": @"", @"variants": @"" },
                              @"endDate": @"",
                              @"id": @0,
                              @"measurements": @"",
                              @"measurementsEsQuery": @"",
                              @"name": @"",
                              @"percentHash": @"",
                              @"publishedStages": @[  ],
                              @"startDate": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/manage/experiments"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/manage/experiments" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"active\": false,\n  \"changedFieldsAndInitialValues\": {},\n  \"complete\": false,\n  \"config\": {\n    \"playerMongoQuery\": \"\",\n    \"playerQuery\": \"\",\n    \"variants\": \"\"\n  },\n  \"endDate\": \"\",\n  \"id\": 0,\n  \"measurements\": \"\",\n  \"measurementsEsQuery\": \"\",\n  \"name\": \"\",\n  \"percentHash\": \"\",\n  \"publishedStages\": [],\n  \"startDate\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/manage/experiments",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'active' => null,
    'changedFieldsAndInitialValues' => [
        
    ],
    'complete' => null,
    'config' => [
        'playerMongoQuery' => '',
        'playerQuery' => '',
        'variants' => ''
    ],
    'endDate' => '',
    'id' => 0,
    'measurements' => '',
    'measurementsEsQuery' => '',
    'name' => '',
    'percentHash' => '',
    'publishedStages' => [
        
    ],
    'startDate' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/restv2/game/:apiKey/manage/experiments', [
  'body' => '{
  "active": false,
  "changedFieldsAndInitialValues": {},
  "complete": false,
  "config": {
    "playerMongoQuery": "",
    "playerQuery": "",
    "variants": ""
  },
  "endDate": "",
  "id": 0,
  "measurements": "",
  "measurementsEsQuery": "",
  "name": "",
  "percentHash": "",
  "publishedStages": [],
  "startDate": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/manage/experiments');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'active' => null,
  'changedFieldsAndInitialValues' => [
    
  ],
  'complete' => null,
  'config' => [
    'playerMongoQuery' => '',
    'playerQuery' => '',
    'variants' => ''
  ],
  'endDate' => '',
  'id' => 0,
  'measurements' => '',
  'measurementsEsQuery' => '',
  'name' => '',
  'percentHash' => '',
  'publishedStages' => [
    
  ],
  'startDate' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'active' => null,
  'changedFieldsAndInitialValues' => [
    
  ],
  'complete' => null,
  'config' => [
    'playerMongoQuery' => '',
    'playerQuery' => '',
    'variants' => ''
  ],
  'endDate' => '',
  'id' => 0,
  'measurements' => '',
  'measurementsEsQuery' => '',
  'name' => '',
  'percentHash' => '',
  'publishedStages' => [
    
  ],
  'startDate' => ''
]));
$request->setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/manage/experiments');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/experiments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "active": false,
  "changedFieldsAndInitialValues": {},
  "complete": false,
  "config": {
    "playerMongoQuery": "",
    "playerQuery": "",
    "variants": ""
  },
  "endDate": "",
  "id": 0,
  "measurements": "",
  "measurementsEsQuery": "",
  "name": "",
  "percentHash": "",
  "publishedStages": [],
  "startDate": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/experiments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "active": false,
  "changedFieldsAndInitialValues": {},
  "complete": false,
  "config": {
    "playerMongoQuery": "",
    "playerQuery": "",
    "variants": ""
  },
  "endDate": "",
  "id": 0,
  "measurements": "",
  "measurementsEsQuery": "",
  "name": "",
  "percentHash": "",
  "publishedStages": [],
  "startDate": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"active\": false,\n  \"changedFieldsAndInitialValues\": {},\n  \"complete\": false,\n  \"config\": {\n    \"playerMongoQuery\": \"\",\n    \"playerQuery\": \"\",\n    \"variants\": \"\"\n  },\n  \"endDate\": \"\",\n  \"id\": 0,\n  \"measurements\": \"\",\n  \"measurementsEsQuery\": \"\",\n  \"name\": \"\",\n  \"percentHash\": \"\",\n  \"publishedStages\": [],\n  \"startDate\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/restv2/game/:apiKey/manage/experiments", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/manage/experiments"

payload = {
    "active": False,
    "changedFieldsAndInitialValues": {},
    "complete": False,
    "config": {
        "playerMongoQuery": "",
        "playerQuery": "",
        "variants": ""
    },
    "endDate": "",
    "id": 0,
    "measurements": "",
    "measurementsEsQuery": "",
    "name": "",
    "percentHash": "",
    "publishedStages": [],
    "startDate": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/manage/experiments"

payload <- "{\n  \"active\": false,\n  \"changedFieldsAndInitialValues\": {},\n  \"complete\": false,\n  \"config\": {\n    \"playerMongoQuery\": \"\",\n    \"playerQuery\": \"\",\n    \"variants\": \"\"\n  },\n  \"endDate\": \"\",\n  \"id\": 0,\n  \"measurements\": \"\",\n  \"measurementsEsQuery\": \"\",\n  \"name\": \"\",\n  \"percentHash\": \"\",\n  \"publishedStages\": [],\n  \"startDate\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/manage/experiments")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"active\": false,\n  \"changedFieldsAndInitialValues\": {},\n  \"complete\": false,\n  \"config\": {\n    \"playerMongoQuery\": \"\",\n    \"playerQuery\": \"\",\n    \"variants\": \"\"\n  },\n  \"endDate\": \"\",\n  \"id\": 0,\n  \"measurements\": \"\",\n  \"measurementsEsQuery\": \"\",\n  \"name\": \"\",\n  \"percentHash\": \"\",\n  \"publishedStages\": [],\n  \"startDate\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/restv2/game/:apiKey/manage/experiments') do |req|
  req.body = "{\n  \"active\": false,\n  \"changedFieldsAndInitialValues\": {},\n  \"complete\": false,\n  \"config\": {\n    \"playerMongoQuery\": \"\",\n    \"playerQuery\": \"\",\n    \"variants\": \"\"\n  },\n  \"endDate\": \"\",\n  \"id\": 0,\n  \"measurements\": \"\",\n  \"measurementsEsQuery\": \"\",\n  \"name\": \"\",\n  \"percentHash\": \"\",\n  \"publishedStages\": [],\n  \"startDate\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/manage/experiments";

    let payload = json!({
        "active": false,
        "changedFieldsAndInitialValues": json!({}),
        "complete": false,
        "config": json!({
            "playerMongoQuery": "",
            "playerQuery": "",
            "variants": ""
        }),
        "endDate": "",
        "id": 0,
        "measurements": "",
        "measurementsEsQuery": "",
        "name": "",
        "percentHash": "",
        "publishedStages": (),
        "startDate": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "active": false,
  "changedFieldsAndInitialValues": {},
  "complete": false,
  "config": {
    "playerMongoQuery": "",
    "playerQuery": "",
    "variants": ""
  },
  "endDate": "",
  "id": 0,
  "measurements": "",
  "measurementsEsQuery": "",
  "name": "",
  "percentHash": "",
  "publishedStages": [],
  "startDate": ""
}' |  \
  http POST {{baseUrl}}/restv2/game/:apiKey/manage/experiments \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "active": false,\n  "changedFieldsAndInitialValues": {},\n  "complete": false,\n  "config": {\n    "playerMongoQuery": "",\n    "playerQuery": "",\n    "variants": ""\n  },\n  "endDate": "",\n  "id": 0,\n  "measurements": "",\n  "measurementsEsQuery": "",\n  "name": "",\n  "percentHash": "",\n  "publishedStages": [],\n  "startDate": ""\n}' \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/manage/experiments

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "active": false,
  "changedFieldsAndInitialValues": [],
  "complete": false,
  "config": [
    "playerMongoQuery": "",
    "playerQuery": "",
    "variants": ""
  ],
  "endDate": "",
  "id": 0,
  "measurements": "",
  "measurementsEsQuery": "",
  "name": "",
  "percentHash": "",
  "publishedStages": [],
  "startDate": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/manage/experiments")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id")

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id"

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

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

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

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

}

DELETE /baseUrl/restv2/game/:apiKey/manage/experiments/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/manage/experiments/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/restv2/game/:apiKey/manage/experiments/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/restv2/game/:apiKey/manage/experiments/:id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id/:action");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id/:action")

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id/:action"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id/:action"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id/:action");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id/:action"

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

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

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

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

}

POST /baseUrl/restv2/game/:apiKey/manage/experiments/:id/:action HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id/:action")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id/:action"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id/:action")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id/:action")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id/:action');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id/:action'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id/:action';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id/:action',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id/:action")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/manage/experiments/:id/:action',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id/:action'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id/:action');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id/:action'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id/:action';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id/:action"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id/:action" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id/:action",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id/:action');

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id/:action');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id/:action');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id/:action' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id/:action' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/restv2/game/:apiKey/manage/experiments/:id/:action")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id/:action"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id/:action"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id/:action")

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

request = Net::HTTP::Post.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/restv2/game/:apiKey/manage/experiments/:id/:action') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id/:action";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id/:action

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id/:action

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id/:action")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id")

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id"

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

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

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

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

}

GET /baseUrl/restv2/game/:apiKey/manage/experiments/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/manage/experiments/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restv2/game/:apiKey/manage/experiments/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/restv2/game/:apiKey/manage/experiments/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/manage/experiments");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restv2/game/:apiKey/manage/experiments")

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/manage/experiments"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/manage/experiments"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/manage/experiments");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/manage/experiments"

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

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

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

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

}

GET /baseUrl/restv2/game/:apiKey/manage/experiments HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restv2/game/:apiKey/manage/experiments")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/manage/experiments"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/experiments")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restv2/game/:apiKey/manage/experiments")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/restv2/game/:apiKey/manage/experiments');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/experiments'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/experiments';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/experiments',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/experiments")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/manage/experiments',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/experiments'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restv2/game/:apiKey/manage/experiments');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/experiments'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/experiments';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/manage/experiments"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/manage/experiments" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/manage/experiments",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/restv2/game/:apiKey/manage/experiments');

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/manage/experiments');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/manage/experiments');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/experiments' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/experiments' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restv2/game/:apiKey/manage/experiments")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/manage/experiments"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/manage/experiments"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/manage/experiments")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/restv2/game/:apiKey/manage/experiments') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/manage/experiments";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/restv2/game/:apiKey/manage/experiments

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/manage/experiments

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/manage/experiments")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"active\": false,\n  \"changedFieldsAndInitialValues\": {},\n  \"complete\": false,\n  \"config\": {\n    \"playerMongoQuery\": \"\",\n    \"playerQuery\": \"\",\n    \"variants\": \"\"\n  },\n  \"endDate\": \"\",\n  \"id\": 0,\n  \"measurements\": \"\",\n  \"measurementsEsQuery\": \"\",\n  \"name\": \"\",\n  \"percentHash\": \"\",\n  \"publishedStages\": [],\n  \"startDate\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id" {:content-type :json
                                                                                      :form-params {:active false
                                                                                                    :changedFieldsAndInitialValues {}
                                                                                                    :complete false
                                                                                                    :config {:playerMongoQuery ""
                                                                                                             :playerQuery ""
                                                                                                             :variants ""}
                                                                                                    :endDate ""
                                                                                                    :id 0
                                                                                                    :measurements ""
                                                                                                    :measurementsEsQuery ""
                                                                                                    :name ""
                                                                                                    :percentHash ""
                                                                                                    :publishedStages []
                                                                                                    :startDate ""}})

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"active\": false,\n  \"changedFieldsAndInitialValues\": {},\n  \"complete\": false,\n  \"config\": {\n    \"playerMongoQuery\": \"\",\n    \"playerQuery\": \"\",\n    \"variants\": \"\"\n  },\n  \"endDate\": \"\",\n  \"id\": 0,\n  \"measurements\": \"\",\n  \"measurementsEsQuery\": \"\",\n  \"name\": \"\",\n  \"percentHash\": \"\",\n  \"publishedStages\": [],\n  \"startDate\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id"),
    Content = new StringContent("{\n  \"active\": false,\n  \"changedFieldsAndInitialValues\": {},\n  \"complete\": false,\n  \"config\": {\n    \"playerMongoQuery\": \"\",\n    \"playerQuery\": \"\",\n    \"variants\": \"\"\n  },\n  \"endDate\": \"\",\n  \"id\": 0,\n  \"measurements\": \"\",\n  \"measurementsEsQuery\": \"\",\n  \"name\": \"\",\n  \"percentHash\": \"\",\n  \"publishedStages\": [],\n  \"startDate\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"active\": false,\n  \"changedFieldsAndInitialValues\": {},\n  \"complete\": false,\n  \"config\": {\n    \"playerMongoQuery\": \"\",\n    \"playerQuery\": \"\",\n    \"variants\": \"\"\n  },\n  \"endDate\": \"\",\n  \"id\": 0,\n  \"measurements\": \"\",\n  \"measurementsEsQuery\": \"\",\n  \"name\": \"\",\n  \"percentHash\": \"\",\n  \"publishedStages\": [],\n  \"startDate\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id"

	payload := strings.NewReader("{\n  \"active\": false,\n  \"changedFieldsAndInitialValues\": {},\n  \"complete\": false,\n  \"config\": {\n    \"playerMongoQuery\": \"\",\n    \"playerQuery\": \"\",\n    \"variants\": \"\"\n  },\n  \"endDate\": \"\",\n  \"id\": 0,\n  \"measurements\": \"\",\n  \"measurementsEsQuery\": \"\",\n  \"name\": \"\",\n  \"percentHash\": \"\",\n  \"publishedStages\": [],\n  \"startDate\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

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

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

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

}

PUT /baseUrl/restv2/game/:apiKey/manage/experiments/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 328

{
  "active": false,
  "changedFieldsAndInitialValues": {},
  "complete": false,
  "config": {
    "playerMongoQuery": "",
    "playerQuery": "",
    "variants": ""
  },
  "endDate": "",
  "id": 0,
  "measurements": "",
  "measurementsEsQuery": "",
  "name": "",
  "percentHash": "",
  "publishedStages": [],
  "startDate": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"active\": false,\n  \"changedFieldsAndInitialValues\": {},\n  \"complete\": false,\n  \"config\": {\n    \"playerMongoQuery\": \"\",\n    \"playerQuery\": \"\",\n    \"variants\": \"\"\n  },\n  \"endDate\": \"\",\n  \"id\": 0,\n  \"measurements\": \"\",\n  \"measurementsEsQuery\": \"\",\n  \"name\": \"\",\n  \"percentHash\": \"\",\n  \"publishedStages\": [],\n  \"startDate\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"active\": false,\n  \"changedFieldsAndInitialValues\": {},\n  \"complete\": false,\n  \"config\": {\n    \"playerMongoQuery\": \"\",\n    \"playerQuery\": \"\",\n    \"variants\": \"\"\n  },\n  \"endDate\": \"\",\n  \"id\": 0,\n  \"measurements\": \"\",\n  \"measurementsEsQuery\": \"\",\n  \"name\": \"\",\n  \"percentHash\": \"\",\n  \"publishedStages\": [],\n  \"startDate\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"active\": false,\n  \"changedFieldsAndInitialValues\": {},\n  \"complete\": false,\n  \"config\": {\n    \"playerMongoQuery\": \"\",\n    \"playerQuery\": \"\",\n    \"variants\": \"\"\n  },\n  \"endDate\": \"\",\n  \"id\": 0,\n  \"measurements\": \"\",\n  \"measurementsEsQuery\": \"\",\n  \"name\": \"\",\n  \"percentHash\": \"\",\n  \"publishedStages\": [],\n  \"startDate\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id")
  .header("content-type", "application/json")
  .body("{\n  \"active\": false,\n  \"changedFieldsAndInitialValues\": {},\n  \"complete\": false,\n  \"config\": {\n    \"playerMongoQuery\": \"\",\n    \"playerQuery\": \"\",\n    \"variants\": \"\"\n  },\n  \"endDate\": \"\",\n  \"id\": 0,\n  \"measurements\": \"\",\n  \"measurementsEsQuery\": \"\",\n  \"name\": \"\",\n  \"percentHash\": \"\",\n  \"publishedStages\": [],\n  \"startDate\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  active: false,
  changedFieldsAndInitialValues: {},
  complete: false,
  config: {
    playerMongoQuery: '',
    playerQuery: '',
    variants: ''
  },
  endDate: '',
  id: 0,
  measurements: '',
  measurementsEsQuery: '',
  name: '',
  percentHash: '',
  publishedStages: [],
  startDate: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id',
  headers: {'content-type': 'application/json'},
  data: {
    active: false,
    changedFieldsAndInitialValues: {},
    complete: false,
    config: {playerMongoQuery: '', playerQuery: '', variants: ''},
    endDate: '',
    id: 0,
    measurements: '',
    measurementsEsQuery: '',
    name: '',
    percentHash: '',
    publishedStages: [],
    startDate: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"active":false,"changedFieldsAndInitialValues":{},"complete":false,"config":{"playerMongoQuery":"","playerQuery":"","variants":""},"endDate":"","id":0,"measurements":"","measurementsEsQuery":"","name":"","percentHash":"","publishedStages":[],"startDate":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "active": false,\n  "changedFieldsAndInitialValues": {},\n  "complete": false,\n  "config": {\n    "playerMongoQuery": "",\n    "playerQuery": "",\n    "variants": ""\n  },\n  "endDate": "",\n  "id": 0,\n  "measurements": "",\n  "measurementsEsQuery": "",\n  "name": "",\n  "percentHash": "",\n  "publishedStages": [],\n  "startDate": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"active\": false,\n  \"changedFieldsAndInitialValues\": {},\n  \"complete\": false,\n  \"config\": {\n    \"playerMongoQuery\": \"\",\n    \"playerQuery\": \"\",\n    \"variants\": \"\"\n  },\n  \"endDate\": \"\",\n  \"id\": 0,\n  \"measurements\": \"\",\n  \"measurementsEsQuery\": \"\",\n  \"name\": \"\",\n  \"percentHash\": \"\",\n  \"publishedStages\": [],\n  \"startDate\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/manage/experiments/:id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  active: false,
  changedFieldsAndInitialValues: {},
  complete: false,
  config: {playerMongoQuery: '', playerQuery: '', variants: ''},
  endDate: '',
  id: 0,
  measurements: '',
  measurementsEsQuery: '',
  name: '',
  percentHash: '',
  publishedStages: [],
  startDate: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id',
  headers: {'content-type': 'application/json'},
  body: {
    active: false,
    changedFieldsAndInitialValues: {},
    complete: false,
    config: {playerMongoQuery: '', playerQuery: '', variants: ''},
    endDate: '',
    id: 0,
    measurements: '',
    measurementsEsQuery: '',
    name: '',
    percentHash: '',
    publishedStages: [],
    startDate: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  active: false,
  changedFieldsAndInitialValues: {},
  complete: false,
  config: {
    playerMongoQuery: '',
    playerQuery: '',
    variants: ''
  },
  endDate: '',
  id: 0,
  measurements: '',
  measurementsEsQuery: '',
  name: '',
  percentHash: '',
  publishedStages: [],
  startDate: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id',
  headers: {'content-type': 'application/json'},
  data: {
    active: false,
    changedFieldsAndInitialValues: {},
    complete: false,
    config: {playerMongoQuery: '', playerQuery: '', variants: ''},
    endDate: '',
    id: 0,
    measurements: '',
    measurementsEsQuery: '',
    name: '',
    percentHash: '',
    publishedStages: [],
    startDate: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"active":false,"changedFieldsAndInitialValues":{},"complete":false,"config":{"playerMongoQuery":"","playerQuery":"","variants":""},"endDate":"","id":0,"measurements":"","measurementsEsQuery":"","name":"","percentHash":"","publishedStages":[],"startDate":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"active": @NO,
                              @"changedFieldsAndInitialValues": @{  },
                              @"complete": @NO,
                              @"config": @{ @"playerMongoQuery": @"", @"playerQuery": @"", @"variants": @"" },
                              @"endDate": @"",
                              @"id": @0,
                              @"measurements": @"",
                              @"measurementsEsQuery": @"",
                              @"name": @"",
                              @"percentHash": @"",
                              @"publishedStages": @[  ],
                              @"startDate": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"active\": false,\n  \"changedFieldsAndInitialValues\": {},\n  \"complete\": false,\n  \"config\": {\n    \"playerMongoQuery\": \"\",\n    \"playerQuery\": \"\",\n    \"variants\": \"\"\n  },\n  \"endDate\": \"\",\n  \"id\": 0,\n  \"measurements\": \"\",\n  \"measurementsEsQuery\": \"\",\n  \"name\": \"\",\n  \"percentHash\": \"\",\n  \"publishedStages\": [],\n  \"startDate\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'active' => null,
    'changedFieldsAndInitialValues' => [
        
    ],
    'complete' => null,
    'config' => [
        'playerMongoQuery' => '',
        'playerQuery' => '',
        'variants' => ''
    ],
    'endDate' => '',
    'id' => 0,
    'measurements' => '',
    'measurementsEsQuery' => '',
    'name' => '',
    'percentHash' => '',
    'publishedStages' => [
        
    ],
    'startDate' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id', [
  'body' => '{
  "active": false,
  "changedFieldsAndInitialValues": {},
  "complete": false,
  "config": {
    "playerMongoQuery": "",
    "playerQuery": "",
    "variants": ""
  },
  "endDate": "",
  "id": 0,
  "measurements": "",
  "measurementsEsQuery": "",
  "name": "",
  "percentHash": "",
  "publishedStages": [],
  "startDate": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'active' => null,
  'changedFieldsAndInitialValues' => [
    
  ],
  'complete' => null,
  'config' => [
    'playerMongoQuery' => '',
    'playerQuery' => '',
    'variants' => ''
  ],
  'endDate' => '',
  'id' => 0,
  'measurements' => '',
  'measurementsEsQuery' => '',
  'name' => '',
  'percentHash' => '',
  'publishedStages' => [
    
  ],
  'startDate' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'active' => null,
  'changedFieldsAndInitialValues' => [
    
  ],
  'complete' => null,
  'config' => [
    'playerMongoQuery' => '',
    'playerQuery' => '',
    'variants' => ''
  ],
  'endDate' => '',
  'id' => 0,
  'measurements' => '',
  'measurementsEsQuery' => '',
  'name' => '',
  'percentHash' => '',
  'publishedStages' => [
    
  ],
  'startDate' => ''
]));
$request->setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "active": false,
  "changedFieldsAndInitialValues": {},
  "complete": false,
  "config": {
    "playerMongoQuery": "",
    "playerQuery": "",
    "variants": ""
  },
  "endDate": "",
  "id": 0,
  "measurements": "",
  "measurementsEsQuery": "",
  "name": "",
  "percentHash": "",
  "publishedStages": [],
  "startDate": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "active": false,
  "changedFieldsAndInitialValues": {},
  "complete": false,
  "config": {
    "playerMongoQuery": "",
    "playerQuery": "",
    "variants": ""
  },
  "endDate": "",
  "id": 0,
  "measurements": "",
  "measurementsEsQuery": "",
  "name": "",
  "percentHash": "",
  "publishedStages": [],
  "startDate": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"active\": false,\n  \"changedFieldsAndInitialValues\": {},\n  \"complete\": false,\n  \"config\": {\n    \"playerMongoQuery\": \"\",\n    \"playerQuery\": \"\",\n    \"variants\": \"\"\n  },\n  \"endDate\": \"\",\n  \"id\": 0,\n  \"measurements\": \"\",\n  \"measurementsEsQuery\": \"\",\n  \"name\": \"\",\n  \"percentHash\": \"\",\n  \"publishedStages\": [],\n  \"startDate\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/restv2/game/:apiKey/manage/experiments/:id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id"

payload = {
    "active": False,
    "changedFieldsAndInitialValues": {},
    "complete": False,
    "config": {
        "playerMongoQuery": "",
        "playerQuery": "",
        "variants": ""
    },
    "endDate": "",
    "id": 0,
    "measurements": "",
    "measurementsEsQuery": "",
    "name": "",
    "percentHash": "",
    "publishedStages": [],
    "startDate": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id"

payload <- "{\n  \"active\": false,\n  \"changedFieldsAndInitialValues\": {},\n  \"complete\": false,\n  \"config\": {\n    \"playerMongoQuery\": \"\",\n    \"playerQuery\": \"\",\n    \"variants\": \"\"\n  },\n  \"endDate\": \"\",\n  \"id\": 0,\n  \"measurements\": \"\",\n  \"measurementsEsQuery\": \"\",\n  \"name\": \"\",\n  \"percentHash\": \"\",\n  \"publishedStages\": [],\n  \"startDate\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"active\": false,\n  \"changedFieldsAndInitialValues\": {},\n  \"complete\": false,\n  \"config\": {\n    \"playerMongoQuery\": \"\",\n    \"playerQuery\": \"\",\n    \"variants\": \"\"\n  },\n  \"endDate\": \"\",\n  \"id\": 0,\n  \"measurements\": \"\",\n  \"measurementsEsQuery\": \"\",\n  \"name\": \"\",\n  \"percentHash\": \"\",\n  \"publishedStages\": [],\n  \"startDate\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/restv2/game/:apiKey/manage/experiments/:id') do |req|
  req.body = "{\n  \"active\": false,\n  \"changedFieldsAndInitialValues\": {},\n  \"complete\": false,\n  \"config\": {\n    \"playerMongoQuery\": \"\",\n    \"playerQuery\": \"\",\n    \"variants\": \"\"\n  },\n  \"endDate\": \"\",\n  \"id\": 0,\n  \"measurements\": \"\",\n  \"measurementsEsQuery\": \"\",\n  \"name\": \"\",\n  \"percentHash\": \"\",\n  \"publishedStages\": [],\n  \"startDate\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id";

    let payload = json!({
        "active": false,
        "changedFieldsAndInitialValues": json!({}),
        "complete": false,
        "config": json!({
            "playerMongoQuery": "",
            "playerQuery": "",
            "variants": ""
        }),
        "endDate": "",
        "id": 0,
        "measurements": "",
        "measurementsEsQuery": "",
        "name": "",
        "percentHash": "",
        "publishedStages": (),
        "startDate": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "active": false,
  "changedFieldsAndInitialValues": {},
  "complete": false,
  "config": {
    "playerMongoQuery": "",
    "playerQuery": "",
    "variants": ""
  },
  "endDate": "",
  "id": 0,
  "measurements": "",
  "measurementsEsQuery": "",
  "name": "",
  "percentHash": "",
  "publishedStages": [],
  "startDate": ""
}' |  \
  http PUT {{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "active": false,\n  "changedFieldsAndInitialValues": {},\n  "complete": false,\n  "config": {\n    "playerMongoQuery": "",\n    "playerQuery": "",\n    "variants": ""\n  },\n  "endDate": "",\n  "id": 0,\n  "measurements": "",\n  "measurementsEsQuery": "",\n  "name": "",\n  "percentHash": "",\n  "publishedStages": [],\n  "startDate": ""\n}' \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "active": false,
  "changedFieldsAndInitialValues": [],
  "complete": false,
  "config": [
    "playerMongoQuery": "",
    "playerQuery": "",
    "variants": ""
  ],
  "endDate": "",
  "id": 0,
  "measurements": "",
  "measurementsEsQuery": "",
  "name": "",
  "percentHash": "",
  "publishedStages": [],
  "startDate": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/manage/experiments/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/endpoints");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restv2/game/:apiKey/endpoints")

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/endpoints"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/endpoints"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/endpoints");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/endpoints"

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

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

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

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

}

GET /baseUrl/restv2/game/:apiKey/endpoints HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restv2/game/:apiKey/endpoints")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/endpoints"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/endpoints")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restv2/game/:apiKey/endpoints")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/restv2/game/:apiKey/endpoints');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/endpoints'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/endpoints';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/endpoints',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/endpoints")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/endpoints',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/endpoints'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restv2/game/:apiKey/endpoints');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/endpoints'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/endpoints';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/endpoints"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/endpoints" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/endpoints",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/restv2/game/:apiKey/endpoints');

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/endpoints');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/endpoints');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/endpoints' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/endpoints' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restv2/game/:apiKey/endpoints")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/endpoints"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/endpoints"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/endpoints")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/restv2/game/:apiKey/endpoints') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/endpoints";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/restv2/game/:apiKey/endpoints

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/endpoints

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/endpoints")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/games");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restv2/games")

require "http/client"

url = "{{baseUrl}}/restv2/games"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/restv2/games"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/games");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/games"

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

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

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

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

}

GET /baseUrl/restv2/games HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restv2/games")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/games"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/games")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restv2/games")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/restv2/games');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/restv2/games'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/games';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/games',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restv2/games")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/games',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/restv2/games'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restv2/games');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/restv2/games'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/games';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/games"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/games" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/games",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/restv2/games');

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/games');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restv2/games');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/games' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/games' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restv2/games")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/games"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/games"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/games")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/restv2/games') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/games";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/restv2/games

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restv2/games

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/games")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/games/deleted");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restv2/games/deleted")

require "http/client"

url = "{{baseUrl}}/restv2/games/deleted"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/restv2/games/deleted"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/games/deleted");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/games/deleted"

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

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

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

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

}

GET /baseUrl/restv2/games/deleted HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restv2/games/deleted")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/games/deleted"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/games/deleted")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restv2/games/deleted")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/restv2/games/deleted');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/restv2/games/deleted'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/games/deleted';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/games/deleted',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restv2/games/deleted")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/games/deleted',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/restv2/games/deleted'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restv2/games/deleted');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/restv2/games/deleted'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/games/deleted';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/games/deleted"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/games/deleted" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/games/deleted",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/restv2/games/deleted');

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/games/deleted');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restv2/games/deleted');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/games/deleted' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/games/deleted' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restv2/games/deleted")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/games/deleted"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/games/deleted"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/games/deleted")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/restv2/games/deleted') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/games/deleted";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/restv2/games/deleted

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restv2/games/deleted

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/games/deleted")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/restore");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/restv2/game/:apiKey/restore")

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/restore"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/restore"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/restore");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/restore"

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

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

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

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

}

POST /baseUrl/restv2/game/:apiKey/restore HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/restv2/game/:apiKey/restore")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/restore"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/restore")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/restv2/game/:apiKey/restore")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/restv2/game/:apiKey/restore');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/restv2/game/:apiKey/restore'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/restore';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/restore',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/restore")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/restore',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/restv2/game/:apiKey/restore'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/restv2/game/:apiKey/restore');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'POST', url: '{{baseUrl}}/restv2/game/:apiKey/restore'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/restore';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/restore"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/restore" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/restore",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/restv2/game/:apiKey/restore');

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/restore');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/restore');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/restore' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/restore' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/restv2/game/:apiKey/restore")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/restore"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/restore"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/restore")

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

request = Net::HTTP::Post.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/restv2/game/:apiKey/restore') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/restore";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/restv2/game/:apiKey/restore

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/restore

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/restore")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey")

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey"

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

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

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

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

}

POST /baseUrl/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey');

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey")

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

request = Net::HTTP::Post.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/copy/to/:targetApiKey")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/manage/queries");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"esRules\": \"\",\n  \"name\": \"\",\n  \"qbRules\": \"\",\n  \"shortCode\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/restv2/game/:apiKey/manage/queries" {:content-type :json
                                                                               :form-params {:esRules ""
                                                                                             :name ""
                                                                                             :qbRules ""
                                                                                             :shortCode ""}})

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/manage/queries"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"esRules\": \"\",\n  \"name\": \"\",\n  \"qbRules\": \"\",\n  \"shortCode\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/manage/queries"),
    Content = new StringContent("{\n  \"esRules\": \"\",\n  \"name\": \"\",\n  \"qbRules\": \"\",\n  \"shortCode\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/manage/queries");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"esRules\": \"\",\n  \"name\": \"\",\n  \"qbRules\": \"\",\n  \"shortCode\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/manage/queries"

	payload := strings.NewReader("{\n  \"esRules\": \"\",\n  \"name\": \"\",\n  \"qbRules\": \"\",\n  \"shortCode\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/restv2/game/:apiKey/manage/queries HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 69

{
  "esRules": "",
  "name": "",
  "qbRules": "",
  "shortCode": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/restv2/game/:apiKey/manage/queries")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"esRules\": \"\",\n  \"name\": \"\",\n  \"qbRules\": \"\",\n  \"shortCode\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/manage/queries"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"esRules\": \"\",\n  \"name\": \"\",\n  \"qbRules\": \"\",\n  \"shortCode\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"esRules\": \"\",\n  \"name\": \"\",\n  \"qbRules\": \"\",\n  \"shortCode\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/queries")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/restv2/game/:apiKey/manage/queries")
  .header("content-type", "application/json")
  .body("{\n  \"esRules\": \"\",\n  \"name\": \"\",\n  \"qbRules\": \"\",\n  \"shortCode\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  esRules: '',
  name: '',
  qbRules: '',
  shortCode: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/restv2/game/:apiKey/manage/queries');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/queries',
  headers: {'content-type': 'application/json'},
  data: {esRules: '', name: '', qbRules: '', shortCode: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/queries';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"esRules":"","name":"","qbRules":"","shortCode":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/queries',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "esRules": "",\n  "name": "",\n  "qbRules": "",\n  "shortCode": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"esRules\": \"\",\n  \"name\": \"\",\n  \"qbRules\": \"\",\n  \"shortCode\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/queries")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/manage/queries',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({esRules: '', name: '', qbRules: '', shortCode: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/queries',
  headers: {'content-type': 'application/json'},
  body: {esRules: '', name: '', qbRules: '', shortCode: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/restv2/game/:apiKey/manage/queries');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  esRules: '',
  name: '',
  qbRules: '',
  shortCode: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/queries',
  headers: {'content-type': 'application/json'},
  data: {esRules: '', name: '', qbRules: '', shortCode: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/queries';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"esRules":"","name":"","qbRules":"","shortCode":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"esRules": @"",
                              @"name": @"",
                              @"qbRules": @"",
                              @"shortCode": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/manage/queries"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/manage/queries" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"esRules\": \"\",\n  \"name\": \"\",\n  \"qbRules\": \"\",\n  \"shortCode\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/manage/queries",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'esRules' => '',
    'name' => '',
    'qbRules' => '',
    'shortCode' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/restv2/game/:apiKey/manage/queries', [
  'body' => '{
  "esRules": "",
  "name": "",
  "qbRules": "",
  "shortCode": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/manage/queries');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'esRules' => '',
  'name' => '',
  'qbRules' => '',
  'shortCode' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'esRules' => '',
  'name' => '',
  'qbRules' => '',
  'shortCode' => ''
]));
$request->setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/manage/queries');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/queries' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "esRules": "",
  "name": "",
  "qbRules": "",
  "shortCode": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/queries' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "esRules": "",
  "name": "",
  "qbRules": "",
  "shortCode": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"esRules\": \"\",\n  \"name\": \"\",\n  \"qbRules\": \"\",\n  \"shortCode\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/restv2/game/:apiKey/manage/queries", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/manage/queries"

payload = {
    "esRules": "",
    "name": "",
    "qbRules": "",
    "shortCode": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/manage/queries"

payload <- "{\n  \"esRules\": \"\",\n  \"name\": \"\",\n  \"qbRules\": \"\",\n  \"shortCode\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/manage/queries")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"esRules\": \"\",\n  \"name\": \"\",\n  \"qbRules\": \"\",\n  \"shortCode\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/restv2/game/:apiKey/manage/queries') do |req|
  req.body = "{\n  \"esRules\": \"\",\n  \"name\": \"\",\n  \"qbRules\": \"\",\n  \"shortCode\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/manage/queries";

    let payload = json!({
        "esRules": "",
        "name": "",
        "qbRules": "",
        "shortCode": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "esRules": "",
  "name": "",
  "qbRules": "",
  "shortCode": ""
}' |  \
  http POST {{baseUrl}}/restv2/game/:apiKey/manage/queries \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "esRules": "",\n  "name": "",\n  "qbRules": "",\n  "shortCode": ""\n}' \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/manage/queries

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "esRules": "",
  "name": "",
  "qbRules": "",
  "shortCode": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/manage/queries")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/manage/screens");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/restv2/game/:apiKey/manage/screens" {:content-type :json
                                                                               :form-params {:groups []
                                                                                             :name ""
                                                                                             :shortCode ""
                                                                                             :template ""}})

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/manage/screens"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/manage/screens"),
    Content = new StringContent("{\n  \"groups\": [],\n  \"name\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/manage/screens");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/manage/screens"

	payload := strings.NewReader("{\n  \"groups\": [],\n  \"name\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/restv2/game/:apiKey/manage/screens HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 69

{
  "groups": [],
  "name": "",
  "shortCode": "",
  "template": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/restv2/game/:apiKey/manage/screens")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"groups\": [],\n  \"name\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/manage/screens"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"groups\": [],\n  \"name\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/screens")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/restv2/game/:apiKey/manage/screens")
  .header("content-type", "application/json")
  .body("{\n  \"groups\": [],\n  \"name\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  groups: [],
  name: '',
  shortCode: '',
  template: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/restv2/game/:apiKey/manage/screens');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/screens',
  headers: {'content-type': 'application/json'},
  data: {groups: [], name: '', shortCode: '', template: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/screens';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"groups":[],"name":"","shortCode":"","template":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/screens',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "groups": [],\n  "name": "",\n  "shortCode": "",\n  "template": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/screens")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/manage/screens',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({groups: [], name: '', shortCode: '', template: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/screens',
  headers: {'content-type': 'application/json'},
  body: {groups: [], name: '', shortCode: '', template: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/restv2/game/:apiKey/manage/screens');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  groups: [],
  name: '',
  shortCode: '',
  template: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/screens',
  headers: {'content-type': 'application/json'},
  data: {groups: [], name: '', shortCode: '', template: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/screens';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"groups":[],"name":"","shortCode":"","template":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"groups": @[  ],
                              @"name": @"",
                              @"shortCode": @"",
                              @"template": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/manage/screens"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/manage/screens" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/manage/screens",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'groups' => [
        
    ],
    'name' => '',
    'shortCode' => '',
    'template' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/restv2/game/:apiKey/manage/screens', [
  'body' => '{
  "groups": [],
  "name": "",
  "shortCode": "",
  "template": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/manage/screens');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'groups' => [
    
  ],
  'name' => '',
  'shortCode' => '',
  'template' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'groups' => [
    
  ],
  'name' => '',
  'shortCode' => '',
  'template' => ''
]));
$request->setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/manage/screens');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/screens' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "groups": [],
  "name": "",
  "shortCode": "",
  "template": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/screens' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "groups": [],
  "name": "",
  "shortCode": "",
  "template": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/restv2/game/:apiKey/manage/screens", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/manage/screens"

payload = {
    "groups": [],
    "name": "",
    "shortCode": "",
    "template": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/manage/screens"

payload <- "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/manage/screens")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/restv2/game/:apiKey/manage/screens') do |req|
  req.body = "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/manage/screens";

    let payload = json!({
        "groups": (),
        "name": "",
        "shortCode": "",
        "template": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "groups": [],
  "name": "",
  "shortCode": "",
  "template": ""
}' |  \
  http POST {{baseUrl}}/restv2/game/:apiKey/manage/screens \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "groups": [],\n  "name": "",\n  "shortCode": "",\n  "template": ""\n}' \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/manage/screens

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "groups": [],
  "name": "",
  "shortCode": "",
  "template": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/manage/screens")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"description\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots" {:content-type :json
                                                                                 :form-params {:description ""}})

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"description\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots"),
    Content = new StringContent("{\n  \"description\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"description\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots"

	payload := strings.NewReader("{\n  \"description\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/restv2/game/:apiKey/manage/snapshots HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 23

{
  "description": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"description\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"description\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"description\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots")
  .header("content-type", "application/json")
  .body("{\n  \"description\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  description: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots',
  headers: {'content-type': 'application/json'},
  data: {description: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"description":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "description": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"description\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/manage/snapshots',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({description: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots',
  headers: {'content-type': 'application/json'},
  body: {description: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  description: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots',
  headers: {'content-type': 'application/json'},
  data: {description: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"description":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"description": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/manage/snapshots"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"description\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'description' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots', [
  'body' => '{
  "description": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/manage/snapshots');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'description' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'description' => ''
]));
$request->setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/manage/snapshots');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "description": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "description": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"description\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/restv2/game/:apiKey/manage/snapshots", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots"

payload = { "description": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots"

payload <- "{\n  \"description\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"description\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/restv2/game/:apiKey/manage/snapshots') do |req|
  req.body = "{\n  \"description\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots";

    let payload = json!({"description": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "description": ""
}' |  \
  http POST {{baseUrl}}/restv2/game/:apiKey/manage/snapshots \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "description": ""\n}' \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/manage/snapshots

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["description": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/manage/snippets");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"script\": \"\",\n  \"scriptData\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/restv2/game/:apiKey/manage/snippets" {:content-type :json
                                                                                :form-params {:groups []
                                                                                              :name ""
                                                                                              :script ""
                                                                                              :scriptData ""
                                                                                              :shortCode ""
                                                                                              :template ""}})

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/manage/snippets"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"script\": \"\",\n  \"scriptData\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/manage/snippets"),
    Content = new StringContent("{\n  \"groups\": [],\n  \"name\": \"\",\n  \"script\": \"\",\n  \"scriptData\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/manage/snippets");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"script\": \"\",\n  \"scriptData\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/manage/snippets"

	payload := strings.NewReader("{\n  \"groups\": [],\n  \"name\": \"\",\n  \"script\": \"\",\n  \"scriptData\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/restv2/game/:apiKey/manage/snippets HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 105

{
  "groups": [],
  "name": "",
  "script": "",
  "scriptData": "",
  "shortCode": "",
  "template": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/restv2/game/:apiKey/manage/snippets")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"groups\": [],\n  \"name\": \"\",\n  \"script\": \"\",\n  \"scriptData\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/manage/snippets"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"groups\": [],\n  \"name\": \"\",\n  \"script\": \"\",\n  \"scriptData\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"script\": \"\",\n  \"scriptData\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/snippets")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/restv2/game/:apiKey/manage/snippets")
  .header("content-type", "application/json")
  .body("{\n  \"groups\": [],\n  \"name\": \"\",\n  \"script\": \"\",\n  \"scriptData\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  groups: [],
  name: '',
  script: '',
  scriptData: '',
  shortCode: '',
  template: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/restv2/game/:apiKey/manage/snippets');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snippets',
  headers: {'content-type': 'application/json'},
  data: {groups: [], name: '', script: '', scriptData: '', shortCode: '', template: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/snippets';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"groups":[],"name":"","script":"","scriptData":"","shortCode":"","template":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snippets',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "groups": [],\n  "name": "",\n  "script": "",\n  "scriptData": "",\n  "shortCode": "",\n  "template": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"script\": \"\",\n  \"scriptData\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/snippets")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/manage/snippets',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({groups: [], name: '', script: '', scriptData: '', shortCode: '', template: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snippets',
  headers: {'content-type': 'application/json'},
  body: {groups: [], name: '', script: '', scriptData: '', shortCode: '', template: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/restv2/game/:apiKey/manage/snippets');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  groups: [],
  name: '',
  script: '',
  scriptData: '',
  shortCode: '',
  template: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snippets',
  headers: {'content-type': 'application/json'},
  data: {groups: [], name: '', script: '', scriptData: '', shortCode: '', template: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/snippets';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"groups":[],"name":"","script":"","scriptData":"","shortCode":"","template":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"groups": @[  ],
                              @"name": @"",
                              @"script": @"",
                              @"scriptData": @"",
                              @"shortCode": @"",
                              @"template": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/manage/snippets"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/manage/snippets" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"script\": \"\",\n  \"scriptData\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/manage/snippets",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'groups' => [
        
    ],
    'name' => '',
    'script' => '',
    'scriptData' => '',
    'shortCode' => '',
    'template' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/restv2/game/:apiKey/manage/snippets', [
  'body' => '{
  "groups": [],
  "name": "",
  "script": "",
  "scriptData": "",
  "shortCode": "",
  "template": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/manage/snippets');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'groups' => [
    
  ],
  'name' => '',
  'script' => '',
  'scriptData' => '',
  'shortCode' => '',
  'template' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'groups' => [
    
  ],
  'name' => '',
  'script' => '',
  'scriptData' => '',
  'shortCode' => '',
  'template' => ''
]));
$request->setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/manage/snippets');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/snippets' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "groups": [],
  "name": "",
  "script": "",
  "scriptData": "",
  "shortCode": "",
  "template": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/snippets' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "groups": [],
  "name": "",
  "script": "",
  "scriptData": "",
  "shortCode": "",
  "template": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"script\": \"\",\n  \"scriptData\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/restv2/game/:apiKey/manage/snippets", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/manage/snippets"

payload = {
    "groups": [],
    "name": "",
    "script": "",
    "scriptData": "",
    "shortCode": "",
    "template": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/manage/snippets"

payload <- "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"script\": \"\",\n  \"scriptData\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/manage/snippets")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"script\": \"\",\n  \"scriptData\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/restv2/game/:apiKey/manage/snippets') do |req|
  req.body = "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"script\": \"\",\n  \"scriptData\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/manage/snippets";

    let payload = json!({
        "groups": (),
        "name": "",
        "script": "",
        "scriptData": "",
        "shortCode": "",
        "template": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "groups": [],
  "name": "",
  "script": "",
  "scriptData": "",
  "shortCode": "",
  "template": ""
}' |  \
  http POST {{baseUrl}}/restv2/game/:apiKey/manage/snippets \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "groups": [],\n  "name": "",\n  "script": "",\n  "scriptData": "",\n  "shortCode": "",\n  "template": ""\n}' \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/manage/snippets

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "groups": [],
  "name": "",
  "script": "",
  "scriptData": "",
  "shortCode": "",
  "template": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/manage/snippets")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode")

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode"

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

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

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

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

}

DELETE /baseUrl/restv2/game/:apiKey/manage/queries/:shortCode HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/manage/queries/:shortCode',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode');

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/restv2/game/:apiKey/manage/queries/:shortCode")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/restv2/game/:apiKey/manage/queries/:shortCode') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode")

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode"

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

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

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

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

}

DELETE /baseUrl/restv2/game/:apiKey/manage/screens/:shortCode HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/manage/screens/:shortCode',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode');

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/restv2/game/:apiKey/manage/screens/:shortCode")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/restv2/game/:apiKey/manage/screens/:shortCode') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId")

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId"

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

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

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

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

}

DELETE /baseUrl/restv2/game/:apiKey/manage/snapshots/:snapshotId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/manage/snapshots/:snapshotId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId');

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/restv2/game/:apiKey/manage/snapshots/:snapshotId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/restv2/game/:apiKey/manage/snapshots/:snapshotId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode")

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode"

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

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

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

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

}

DELETE /baseUrl/restv2/game/:apiKey/manage/snippets/:shortCode HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/manage/snippets/:shortCode',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode');

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/restv2/game/:apiKey/manage/snippets/:shortCode")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/restv2/game/:apiKey/manage/snippets/:shortCode') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode")

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode"

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

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

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

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

}

GET /baseUrl/restv2/game/:apiKey/manage/queries/:shortCode HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/manage/queries/:shortCode',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode');

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restv2/game/:apiKey/manage/queries/:shortCode")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/restv2/game/:apiKey/manage/queries/:shortCode') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode")

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode"

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

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

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

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

}

GET /baseUrl/restv2/game/:apiKey/manage/screens/:shortCode HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/manage/screens/:shortCode',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode');

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restv2/game/:apiKey/manage/screens/:shortCode")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/restv2/game/:apiKey/manage/screens/:shortCode') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode")

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode"

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

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

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

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

}

GET /baseUrl/restv2/game/:apiKey/manage/snippets/:shortCode HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/manage/snippets/:shortCode',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode');

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restv2/game/:apiKey/manage/snippets/:shortCode")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/restv2/game/:apiKey/manage/snippets/:shortCode') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/manage/screens/executable");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restv2/game/:apiKey/manage/screens/executable")

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/manage/screens/executable"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/manage/screens/executable"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/manage/screens/executable");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/manage/screens/executable"

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

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

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

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

}

GET /baseUrl/restv2/game/:apiKey/manage/screens/executable HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restv2/game/:apiKey/manage/screens/executable")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/manage/screens/executable"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/screens/executable")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restv2/game/:apiKey/manage/screens/executable")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/restv2/game/:apiKey/manage/screens/executable');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/screens/executable'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/screens/executable';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/screens/executable',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/screens/executable")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/manage/screens/executable',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/screens/executable'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restv2/game/:apiKey/manage/screens/executable');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/screens/executable'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/screens/executable';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/manage/screens/executable"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/manage/screens/executable" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/manage/screens/executable",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/restv2/game/:apiKey/manage/screens/executable');

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/manage/screens/executable');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/manage/screens/executable');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/screens/executable' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/screens/executable' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restv2/game/:apiKey/manage/screens/executable")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/manage/screens/executable"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/manage/screens/executable"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/manage/screens/executable")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/restv2/game/:apiKey/manage/screens/executable') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/manage/screens/executable";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/restv2/game/:apiKey/manage/screens/executable

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/manage/screens/executable

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/manage/screens/executable")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/manage/queries");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restv2/game/:apiKey/manage/queries")

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/manage/queries"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/manage/queries"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/manage/queries");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/manage/queries"

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

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

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

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

}

GET /baseUrl/restv2/game/:apiKey/manage/queries HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restv2/game/:apiKey/manage/queries")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/manage/queries"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/queries")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restv2/game/:apiKey/manage/queries")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/restv2/game/:apiKey/manage/queries');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/queries'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/queries';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/queries',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/queries")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/manage/queries',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/queries'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restv2/game/:apiKey/manage/queries');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/queries'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/queries';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/manage/queries"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/manage/queries" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/manage/queries",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/restv2/game/:apiKey/manage/queries');

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/manage/queries');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/manage/queries');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/queries' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/queries' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restv2/game/:apiKey/manage/queries")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/manage/queries"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/manage/queries"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/manage/queries")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/restv2/game/:apiKey/manage/queries') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/manage/queries";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/restv2/game/:apiKey/manage/queries

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/manage/queries

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/manage/queries")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/manage/screens");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restv2/game/:apiKey/manage/screens")

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/manage/screens"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/manage/screens"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/manage/screens");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/manage/screens"

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

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

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

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

}

GET /baseUrl/restv2/game/:apiKey/manage/screens HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restv2/game/:apiKey/manage/screens")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/manage/screens"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/screens")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restv2/game/:apiKey/manage/screens")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/restv2/game/:apiKey/manage/screens');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/screens'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/screens';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/screens',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/screens")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/manage/screens',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/screens'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restv2/game/:apiKey/manage/screens');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/screens'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/screens';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/manage/screens"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/manage/screens" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/manage/screens",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/restv2/game/:apiKey/manage/screens');

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/manage/screens');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/manage/screens');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/screens' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/screens' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restv2/game/:apiKey/manage/screens")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/manage/screens"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/manage/screens"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/manage/screens")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/restv2/game/:apiKey/manage/screens') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/manage/screens";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/restv2/game/:apiKey/manage/screens

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/manage/screens

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/manage/screens")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots")

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots"

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

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

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

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

}

GET /baseUrl/restv2/game/:apiKey/manage/snapshots HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/manage/snapshots',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/manage/snapshots"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots');

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/manage/snapshots');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/manage/snapshots');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restv2/game/:apiKey/manage/snapshots")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/restv2/game/:apiKey/manage/snapshots') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/restv2/game/:apiKey/manage/snapshots

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/manage/snapshots

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/manage/snippets");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restv2/game/:apiKey/manage/snippets")

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/manage/snippets"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/manage/snippets"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/manage/snippets");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/manage/snippets"

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

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

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

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

}

GET /baseUrl/restv2/game/:apiKey/manage/snippets HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restv2/game/:apiKey/manage/snippets")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/manage/snippets"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/snippets")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restv2/game/:apiKey/manage/snippets")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/restv2/game/:apiKey/manage/snippets');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snippets'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/snippets';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snippets',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/snippets")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/manage/snippets',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snippets'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restv2/game/:apiKey/manage/snippets');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snippets'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/snippets';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/manage/snippets"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/manage/snippets" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/manage/snippets",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/restv2/game/:apiKey/manage/snippets');

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/manage/snippets');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/manage/snippets');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/snippets' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/snippets' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restv2/game/:apiKey/manage/snippets")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/manage/snippets"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/manage/snippets"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/manage/snippets")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/restv2/game/:apiKey/manage/snippets') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/manage/snippets";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/restv2/game/:apiKey/manage/snippets

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/manage/snippets

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/manage/snippets")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish")

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish"

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

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

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

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

}

POST /baseUrl/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish');

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish")

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

request = Net::HTTP::Post.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/publish")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert")

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert"

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

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

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

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

}

POST /baseUrl/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert');

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert")

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

request = Net::HTTP::Post.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/manage/snapshots/:snapshotId/revert")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"esRules\": \"\",\n  \"name\": \"\",\n  \"qbRules\": \"\",\n  \"shortCode\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode" {:content-type :json
                                                                                         :form-params {:esRules ""
                                                                                                       :name ""
                                                                                                       :qbRules ""
                                                                                                       :shortCode ""}})

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"esRules\": \"\",\n  \"name\": \"\",\n  \"qbRules\": \"\",\n  \"shortCode\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode"),
    Content = new StringContent("{\n  \"esRules\": \"\",\n  \"name\": \"\",\n  \"qbRules\": \"\",\n  \"shortCode\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"esRules\": \"\",\n  \"name\": \"\",\n  \"qbRules\": \"\",\n  \"shortCode\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode"

	payload := strings.NewReader("{\n  \"esRules\": \"\",\n  \"name\": \"\",\n  \"qbRules\": \"\",\n  \"shortCode\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

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

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

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

}

PUT /baseUrl/restv2/game/:apiKey/manage/queries/:shortCode HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 69

{
  "esRules": "",
  "name": "",
  "qbRules": "",
  "shortCode": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"esRules\": \"\",\n  \"name\": \"\",\n  \"qbRules\": \"\",\n  \"shortCode\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"esRules\": \"\",\n  \"name\": \"\",\n  \"qbRules\": \"\",\n  \"shortCode\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"esRules\": \"\",\n  \"name\": \"\",\n  \"qbRules\": \"\",\n  \"shortCode\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode")
  .header("content-type", "application/json")
  .body("{\n  \"esRules\": \"\",\n  \"name\": \"\",\n  \"qbRules\": \"\",\n  \"shortCode\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  esRules: '',
  name: '',
  qbRules: '',
  shortCode: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode',
  headers: {'content-type': 'application/json'},
  data: {esRules: '', name: '', qbRules: '', shortCode: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"esRules":"","name":"","qbRules":"","shortCode":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "esRules": "",\n  "name": "",\n  "qbRules": "",\n  "shortCode": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"esRules\": \"\",\n  \"name\": \"\",\n  \"qbRules\": \"\",\n  \"shortCode\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/manage/queries/:shortCode',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({esRules: '', name: '', qbRules: '', shortCode: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode',
  headers: {'content-type': 'application/json'},
  body: {esRules: '', name: '', qbRules: '', shortCode: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  esRules: '',
  name: '',
  qbRules: '',
  shortCode: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode',
  headers: {'content-type': 'application/json'},
  data: {esRules: '', name: '', qbRules: '', shortCode: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"esRules":"","name":"","qbRules":"","shortCode":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"esRules": @"",
                              @"name": @"",
                              @"qbRules": @"",
                              @"shortCode": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"esRules\": \"\",\n  \"name\": \"\",\n  \"qbRules\": \"\",\n  \"shortCode\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'esRules' => '',
    'name' => '',
    'qbRules' => '',
    'shortCode' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode', [
  'body' => '{
  "esRules": "",
  "name": "",
  "qbRules": "",
  "shortCode": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'esRules' => '',
  'name' => '',
  'qbRules' => '',
  'shortCode' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'esRules' => '',
  'name' => '',
  'qbRules' => '',
  'shortCode' => ''
]));
$request->setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "esRules": "",
  "name": "",
  "qbRules": "",
  "shortCode": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "esRules": "",
  "name": "",
  "qbRules": "",
  "shortCode": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"esRules\": \"\",\n  \"name\": \"\",\n  \"qbRules\": \"\",\n  \"shortCode\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/restv2/game/:apiKey/manage/queries/:shortCode", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode"

payload = {
    "esRules": "",
    "name": "",
    "qbRules": "",
    "shortCode": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode"

payload <- "{\n  \"esRules\": \"\",\n  \"name\": \"\",\n  \"qbRules\": \"\",\n  \"shortCode\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"esRules\": \"\",\n  \"name\": \"\",\n  \"qbRules\": \"\",\n  \"shortCode\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/restv2/game/:apiKey/manage/queries/:shortCode') do |req|
  req.body = "{\n  \"esRules\": \"\",\n  \"name\": \"\",\n  \"qbRules\": \"\",\n  \"shortCode\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode";

    let payload = json!({
        "esRules": "",
        "name": "",
        "qbRules": "",
        "shortCode": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "esRules": "",
  "name": "",
  "qbRules": "",
  "shortCode": ""
}' |  \
  http PUT {{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "esRules": "",\n  "name": "",\n  "qbRules": "",\n  "shortCode": ""\n}' \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "esRules": "",
  "name": "",
  "qbRules": "",
  "shortCode": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/manage/queries/:shortCode")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode" {:content-type :json
                                                                                         :form-params {:groups []
                                                                                                       :name ""
                                                                                                       :shortCode ""
                                                                                                       :template ""}})

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode"),
    Content = new StringContent("{\n  \"groups\": [],\n  \"name\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode"

	payload := strings.NewReader("{\n  \"groups\": [],\n  \"name\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

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

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

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

}

PUT /baseUrl/restv2/game/:apiKey/manage/screens/:shortCode HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 69

{
  "groups": [],
  "name": "",
  "shortCode": "",
  "template": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"groups\": [],\n  \"name\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"groups\": [],\n  \"name\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode")
  .header("content-type", "application/json")
  .body("{\n  \"groups\": [],\n  \"name\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  groups: [],
  name: '',
  shortCode: '',
  template: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode',
  headers: {'content-type': 'application/json'},
  data: {groups: [], name: '', shortCode: '', template: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"groups":[],"name":"","shortCode":"","template":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "groups": [],\n  "name": "",\n  "shortCode": "",\n  "template": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/manage/screens/:shortCode',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({groups: [], name: '', shortCode: '', template: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode',
  headers: {'content-type': 'application/json'},
  body: {groups: [], name: '', shortCode: '', template: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  groups: [],
  name: '',
  shortCode: '',
  template: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode',
  headers: {'content-type': 'application/json'},
  data: {groups: [], name: '', shortCode: '', template: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"groups":[],"name":"","shortCode":"","template":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"groups": @[  ],
                              @"name": @"",
                              @"shortCode": @"",
                              @"template": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'groups' => [
        
    ],
    'name' => '',
    'shortCode' => '',
    'template' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode', [
  'body' => '{
  "groups": [],
  "name": "",
  "shortCode": "",
  "template": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'groups' => [
    
  ],
  'name' => '',
  'shortCode' => '',
  'template' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'groups' => [
    
  ],
  'name' => '',
  'shortCode' => '',
  'template' => ''
]));
$request->setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "groups": [],
  "name": "",
  "shortCode": "",
  "template": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "groups": [],
  "name": "",
  "shortCode": "",
  "template": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/restv2/game/:apiKey/manage/screens/:shortCode", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode"

payload = {
    "groups": [],
    "name": "",
    "shortCode": "",
    "template": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode"

payload <- "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/restv2/game/:apiKey/manage/screens/:shortCode') do |req|
  req.body = "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode";

    let payload = json!({
        "groups": (),
        "name": "",
        "shortCode": "",
        "template": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "groups": [],
  "name": "",
  "shortCode": "",
  "template": ""
}' |  \
  http PUT {{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "groups": [],\n  "name": "",\n  "shortCode": "",\n  "template": ""\n}' \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "groups": [],
  "name": "",
  "shortCode": "",
  "template": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/manage/screens/:shortCode")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"script\": \"\",\n  \"scriptData\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode" {:content-type :json
                                                                                          :form-params {:groups []
                                                                                                        :name ""
                                                                                                        :script ""
                                                                                                        :scriptData ""
                                                                                                        :shortCode ""
                                                                                                        :template ""}})

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"script\": \"\",\n  \"scriptData\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode"),
    Content = new StringContent("{\n  \"groups\": [],\n  \"name\": \"\",\n  \"script\": \"\",\n  \"scriptData\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"script\": \"\",\n  \"scriptData\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode"

	payload := strings.NewReader("{\n  \"groups\": [],\n  \"name\": \"\",\n  \"script\": \"\",\n  \"scriptData\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

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

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

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

}

PUT /baseUrl/restv2/game/:apiKey/manage/snippets/:shortCode HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 105

{
  "groups": [],
  "name": "",
  "script": "",
  "scriptData": "",
  "shortCode": "",
  "template": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"groups\": [],\n  \"name\": \"\",\n  \"script\": \"\",\n  \"scriptData\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"groups\": [],\n  \"name\": \"\",\n  \"script\": \"\",\n  \"scriptData\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"script\": \"\",\n  \"scriptData\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode")
  .header("content-type", "application/json")
  .body("{\n  \"groups\": [],\n  \"name\": \"\",\n  \"script\": \"\",\n  \"scriptData\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  groups: [],
  name: '',
  script: '',
  scriptData: '',
  shortCode: '',
  template: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode',
  headers: {'content-type': 'application/json'},
  data: {groups: [], name: '', script: '', scriptData: '', shortCode: '', template: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"groups":[],"name":"","script":"","scriptData":"","shortCode":"","template":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "groups": [],\n  "name": "",\n  "script": "",\n  "scriptData": "",\n  "shortCode": "",\n  "template": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"script\": \"\",\n  \"scriptData\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/manage/snippets/:shortCode',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({groups: [], name: '', script: '', scriptData: '', shortCode: '', template: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode',
  headers: {'content-type': 'application/json'},
  body: {groups: [], name: '', script: '', scriptData: '', shortCode: '', template: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  groups: [],
  name: '',
  script: '',
  scriptData: '',
  shortCode: '',
  template: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode',
  headers: {'content-type': 'application/json'},
  data: {groups: [], name: '', script: '', scriptData: '', shortCode: '', template: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"groups":[],"name":"","script":"","scriptData":"","shortCode":"","template":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"groups": @[  ],
                              @"name": @"",
                              @"script": @"",
                              @"scriptData": @"",
                              @"shortCode": @"",
                              @"template": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"script\": \"\",\n  \"scriptData\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'groups' => [
        
    ],
    'name' => '',
    'script' => '',
    'scriptData' => '',
    'shortCode' => '',
    'template' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode', [
  'body' => '{
  "groups": [],
  "name": "",
  "script": "",
  "scriptData": "",
  "shortCode": "",
  "template": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'groups' => [
    
  ],
  'name' => '',
  'script' => '',
  'scriptData' => '',
  'shortCode' => '',
  'template' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'groups' => [
    
  ],
  'name' => '',
  'script' => '',
  'scriptData' => '',
  'shortCode' => '',
  'template' => ''
]));
$request->setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "groups": [],
  "name": "",
  "script": "",
  "scriptData": "",
  "shortCode": "",
  "template": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "groups": [],
  "name": "",
  "script": "",
  "scriptData": "",
  "shortCode": "",
  "template": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"script\": \"\",\n  \"scriptData\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/restv2/game/:apiKey/manage/snippets/:shortCode", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode"

payload = {
    "groups": [],
    "name": "",
    "script": "",
    "scriptData": "",
    "shortCode": "",
    "template": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode"

payload <- "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"script\": \"\",\n  \"scriptData\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"script\": \"\",\n  \"scriptData\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/restv2/game/:apiKey/manage/snippets/:shortCode') do |req|
  req.body = "{\n  \"groups\": [],\n  \"name\": \"\",\n  \"script\": \"\",\n  \"scriptData\": \"\",\n  \"shortCode\": \"\",\n  \"template\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode";

    let payload = json!({
        "groups": (),
        "name": "",
        "script": "",
        "scriptData": "",
        "shortCode": "",
        "template": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "groups": [],
  "name": "",
  "script": "",
  "scriptData": "",
  "shortCode": "",
  "template": ""
}' |  \
  http PUT {{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "groups": [],\n  "name": "",\n  "script": "",\n  "scriptData": "",\n  "shortCode": "",\n  "template": ""\n}' \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "groups": [],
  "name": "",
  "script": "",
  "scriptData": "",
  "shortCode": "",
  "template": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/manage/snippets/:shortCode")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/admin/notifications/summary?stage=&startDate=&endDate=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restv2/game/:apiKey/admin/notifications/summary" {:query-params {:stage ""
                                                                                                          :startDate ""
                                                                                                          :endDate ""}})

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/admin/notifications/summary?stage=&startDate=&endDate="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/admin/notifications/summary?stage=&startDate=&endDate="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/admin/notifications/summary?stage=&startDate=&endDate=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/admin/notifications/summary?stage=&startDate=&endDate="

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

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

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

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

}

GET /baseUrl/restv2/game/:apiKey/admin/notifications/summary?stage=&startDate=&endDate= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restv2/game/:apiKey/admin/notifications/summary?stage=&startDate=&endDate=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/admin/notifications/summary?stage=&startDate=&endDate="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/admin/notifications/summary?stage=&startDate=&endDate=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restv2/game/:apiKey/admin/notifications/summary?stage=&startDate=&endDate=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/restv2/game/:apiKey/admin/notifications/summary?stage=&startDate=&endDate=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/notifications/summary',
  params: {stage: '', startDate: '', endDate: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/admin/notifications/summary?stage=&startDate=&endDate=';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/notifications/summary?stage=&startDate=&endDate=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/admin/notifications/summary?stage=&startDate=&endDate=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/admin/notifications/summary?stage=&startDate=&endDate=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/notifications/summary',
  qs: {stage: '', startDate: '', endDate: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restv2/game/:apiKey/admin/notifications/summary');

req.query({
  stage: '',
  startDate: '',
  endDate: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/notifications/summary',
  params: {stage: '', startDate: '', endDate: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/admin/notifications/summary?stage=&startDate=&endDate=';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/admin/notifications/summary?stage=&startDate=&endDate="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/admin/notifications/summary?stage=&startDate=&endDate=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/admin/notifications/summary?stage=&startDate=&endDate=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/restv2/game/:apiKey/admin/notifications/summary?stage=&startDate=&endDate=');

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/admin/notifications/summary');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'stage' => '',
  'startDate' => '',
  'endDate' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/admin/notifications/summary');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'stage' => '',
  'startDate' => '',
  'endDate' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/admin/notifications/summary?stage=&startDate=&endDate=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/admin/notifications/summary?stage=&startDate=&endDate=' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restv2/game/:apiKey/admin/notifications/summary?stage=&startDate=&endDate=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/admin/notifications/summary"

querystring = {"stage":"","startDate":"","endDate":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/admin/notifications/summary"

queryString <- list(
  stage = "",
  startDate = "",
  endDate = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/admin/notifications/summary?stage=&startDate=&endDate=")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/restv2/game/:apiKey/admin/notifications/summary') do |req|
  req.params['stage'] = ''
  req.params['startDate'] = ''
  req.params['endDate'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/admin/notifications/summary";

    let querystring = [
        ("stage", ""),
        ("startDate", ""),
        ("endDate", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET '{{baseUrl}}/restv2/game/:apiKey/admin/notifications/summary?stage=&startDate=&endDate='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/restv2/game/:apiKey/admin/notifications/summary?stage=&startDate=&endDate='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/admin/notifications/summary?stage=&startDate=&endDate=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/amazon");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/amazon" {:content-type :json
                                                                                                    :form-params {:customJson ""
                                                                                                                  :messageId ""
                                                                                                                  :pushId ""
                                                                                                                  :subtitle ""
                                                                                                                  :summary ""
                                                                                                                  :title ""}})

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/amazon"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/amazon"),
    Content = new StringContent("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/amazon");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/amazon"

	payload := strings.NewReader("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/restv2/game/:apiKey/admin/pushNotifications/test/amazon HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 107

{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/amazon")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/amazon"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/amazon")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/amazon")
  .header("content-type", "application/json")
  .body("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  customJson: '',
  messageId: '',
  pushId: '',
  subtitle: '',
  summary: '',
  title: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/amazon');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/amazon',
  headers: {'content-type': 'application/json'},
  data: {
    customJson: '',
    messageId: '',
    pushId: '',
    subtitle: '',
    summary: '',
    title: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/amazon';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"customJson":"","messageId":"","pushId":"","subtitle":"","summary":"","title":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/amazon',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "customJson": "",\n  "messageId": "",\n  "pushId": "",\n  "subtitle": "",\n  "summary": "",\n  "title": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/amazon")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/admin/pushNotifications/test/amazon',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  customJson: '',
  messageId: '',
  pushId: '',
  subtitle: '',
  summary: '',
  title: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/amazon',
  headers: {'content-type': 'application/json'},
  body: {
    customJson: '',
    messageId: '',
    pushId: '',
    subtitle: '',
    summary: '',
    title: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/amazon');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  customJson: '',
  messageId: '',
  pushId: '',
  subtitle: '',
  summary: '',
  title: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/amazon',
  headers: {'content-type': 'application/json'},
  data: {
    customJson: '',
    messageId: '',
    pushId: '',
    subtitle: '',
    summary: '',
    title: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/amazon';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"customJson":"","messageId":"","pushId":"","subtitle":"","summary":"","title":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"customJson": @"",
                              @"messageId": @"",
                              @"pushId": @"",
                              @"subtitle": @"",
                              @"summary": @"",
                              @"title": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/amazon"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/amazon" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/amazon",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'customJson' => '',
    'messageId' => '',
    'pushId' => '',
    'subtitle' => '',
    'summary' => '',
    'title' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/amazon', [
  'body' => '{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/amazon');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'customJson' => '',
  'messageId' => '',
  'pushId' => '',
  'subtitle' => '',
  'summary' => '',
  'title' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'customJson' => '',
  'messageId' => '',
  'pushId' => '',
  'subtitle' => '',
  'summary' => '',
  'title' => ''
]));
$request->setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/amazon');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/amazon' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/amazon' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/restv2/game/:apiKey/admin/pushNotifications/test/amazon", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/amazon"

payload = {
    "customJson": "",
    "messageId": "",
    "pushId": "",
    "subtitle": "",
    "summary": "",
    "title": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/amazon"

payload <- "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/amazon")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/restv2/game/:apiKey/admin/pushNotifications/test/amazon') do |req|
  req.body = "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/amazon";

    let payload = json!({
        "customJson": "",
        "messageId": "",
        "pushId": "",
        "subtitle": "",
        "summary": "",
        "title": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}' |  \
  http POST {{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/amazon \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "customJson": "",\n  "messageId": "",\n  "pushId": "",\n  "subtitle": "",\n  "summary": "",\n  "title": ""\n}' \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/amazon

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/amazon")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/development");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/development" {:content-type :json
                                                                                                               :form-params {:customJson ""
                                                                                                                             :messageId ""
                                                                                                                             :pushId ""
                                                                                                                             :subtitle ""
                                                                                                                             :summary ""
                                                                                                                             :title ""}})

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/development"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/development"),
    Content = new StringContent("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/development");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/development"

	payload := strings.NewReader("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/restv2/game/:apiKey/admin/pushNotifications/test/apple/development HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 107

{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/development")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/development"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/development")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/development")
  .header("content-type", "application/json")
  .body("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  customJson: '',
  messageId: '',
  pushId: '',
  subtitle: '',
  summary: '',
  title: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/development');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/development',
  headers: {'content-type': 'application/json'},
  data: {
    customJson: '',
    messageId: '',
    pushId: '',
    subtitle: '',
    summary: '',
    title: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/development';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"customJson":"","messageId":"","pushId":"","subtitle":"","summary":"","title":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/development',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "customJson": "",\n  "messageId": "",\n  "pushId": "",\n  "subtitle": "",\n  "summary": "",\n  "title": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/development")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/admin/pushNotifications/test/apple/development',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  customJson: '',
  messageId: '',
  pushId: '',
  subtitle: '',
  summary: '',
  title: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/development',
  headers: {'content-type': 'application/json'},
  body: {
    customJson: '',
    messageId: '',
    pushId: '',
    subtitle: '',
    summary: '',
    title: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/development');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  customJson: '',
  messageId: '',
  pushId: '',
  subtitle: '',
  summary: '',
  title: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/development',
  headers: {'content-type': 'application/json'},
  data: {
    customJson: '',
    messageId: '',
    pushId: '',
    subtitle: '',
    summary: '',
    title: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/development';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"customJson":"","messageId":"","pushId":"","subtitle":"","summary":"","title":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"customJson": @"",
                              @"messageId": @"",
                              @"pushId": @"",
                              @"subtitle": @"",
                              @"summary": @"",
                              @"title": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/development"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/development" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/development",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'customJson' => '',
    'messageId' => '',
    'pushId' => '',
    'subtitle' => '',
    'summary' => '',
    'title' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/development', [
  'body' => '{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/development');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'customJson' => '',
  'messageId' => '',
  'pushId' => '',
  'subtitle' => '',
  'summary' => '',
  'title' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'customJson' => '',
  'messageId' => '',
  'pushId' => '',
  'subtitle' => '',
  'summary' => '',
  'title' => ''
]));
$request->setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/development');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/development' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/development' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/restv2/game/:apiKey/admin/pushNotifications/test/apple/development", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/development"

payload = {
    "customJson": "",
    "messageId": "",
    "pushId": "",
    "subtitle": "",
    "summary": "",
    "title": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/development"

payload <- "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/development")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/restv2/game/:apiKey/admin/pushNotifications/test/apple/development') do |req|
  req.body = "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/development";

    let payload = json!({
        "customJson": "",
        "messageId": "",
        "pushId": "",
        "subtitle": "",
        "summary": "",
        "title": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}' |  \
  http POST {{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/development \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "customJson": "",\n  "messageId": "",\n  "pushId": "",\n  "subtitle": "",\n  "summary": "",\n  "title": ""\n}' \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/development

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/development")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/production");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/production" {:content-type :json
                                                                                                              :form-params {:customJson ""
                                                                                                                            :messageId ""
                                                                                                                            :pushId ""
                                                                                                                            :subtitle ""
                                                                                                                            :summary ""
                                                                                                                            :title ""}})

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/production"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/production"),
    Content = new StringContent("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/production");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/production"

	payload := strings.NewReader("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/restv2/game/:apiKey/admin/pushNotifications/test/apple/production HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 107

{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/production")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/production"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/production")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/production")
  .header("content-type", "application/json")
  .body("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  customJson: '',
  messageId: '',
  pushId: '',
  subtitle: '',
  summary: '',
  title: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/production');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/production',
  headers: {'content-type': 'application/json'},
  data: {
    customJson: '',
    messageId: '',
    pushId: '',
    subtitle: '',
    summary: '',
    title: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/production';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"customJson":"","messageId":"","pushId":"","subtitle":"","summary":"","title":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/production',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "customJson": "",\n  "messageId": "",\n  "pushId": "",\n  "subtitle": "",\n  "summary": "",\n  "title": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/production")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/admin/pushNotifications/test/apple/production',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  customJson: '',
  messageId: '',
  pushId: '',
  subtitle: '',
  summary: '',
  title: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/production',
  headers: {'content-type': 'application/json'},
  body: {
    customJson: '',
    messageId: '',
    pushId: '',
    subtitle: '',
    summary: '',
    title: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/production');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  customJson: '',
  messageId: '',
  pushId: '',
  subtitle: '',
  summary: '',
  title: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/production',
  headers: {'content-type': 'application/json'},
  data: {
    customJson: '',
    messageId: '',
    pushId: '',
    subtitle: '',
    summary: '',
    title: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/production';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"customJson":"","messageId":"","pushId":"","subtitle":"","summary":"","title":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"customJson": @"",
                              @"messageId": @"",
                              @"pushId": @"",
                              @"subtitle": @"",
                              @"summary": @"",
                              @"title": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/production"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/production" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/production",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'customJson' => '',
    'messageId' => '',
    'pushId' => '',
    'subtitle' => '',
    'summary' => '',
    'title' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/production', [
  'body' => '{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/production');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'customJson' => '',
  'messageId' => '',
  'pushId' => '',
  'subtitle' => '',
  'summary' => '',
  'title' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'customJson' => '',
  'messageId' => '',
  'pushId' => '',
  'subtitle' => '',
  'summary' => '',
  'title' => ''
]));
$request->setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/production');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/production' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/production' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/restv2/game/:apiKey/admin/pushNotifications/test/apple/production", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/production"

payload = {
    "customJson": "",
    "messageId": "",
    "pushId": "",
    "subtitle": "",
    "summary": "",
    "title": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/production"

payload <- "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/production")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/restv2/game/:apiKey/admin/pushNotifications/test/apple/production') do |req|
  req.body = "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/production";

    let payload = json!({
        "customJson": "",
        "messageId": "",
        "pushId": "",
        "subtitle": "",
        "summary": "",
        "title": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}' |  \
  http POST {{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/production \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "customJson": "",\n  "messageId": "",\n  "pushId": "",\n  "subtitle": "",\n  "summary": "",\n  "title": ""\n}' \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/production

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/apple/production")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/google");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/google" {:content-type :json
                                                                                                    :form-params {:customJson ""
                                                                                                                  :messageId ""
                                                                                                                  :pushId ""
                                                                                                                  :subtitle ""
                                                                                                                  :summary ""
                                                                                                                  :title ""}})

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/google"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/google"),
    Content = new StringContent("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/google");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/google"

	payload := strings.NewReader("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/restv2/game/:apiKey/admin/pushNotifications/test/google HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 107

{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/google")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/google"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/google")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/google")
  .header("content-type", "application/json")
  .body("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  customJson: '',
  messageId: '',
  pushId: '',
  subtitle: '',
  summary: '',
  title: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/google');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/google',
  headers: {'content-type': 'application/json'},
  data: {
    customJson: '',
    messageId: '',
    pushId: '',
    subtitle: '',
    summary: '',
    title: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/google';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"customJson":"","messageId":"","pushId":"","subtitle":"","summary":"","title":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/google',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "customJson": "",\n  "messageId": "",\n  "pushId": "",\n  "subtitle": "",\n  "summary": "",\n  "title": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/google")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/admin/pushNotifications/test/google',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  customJson: '',
  messageId: '',
  pushId: '',
  subtitle: '',
  summary: '',
  title: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/google',
  headers: {'content-type': 'application/json'},
  body: {
    customJson: '',
    messageId: '',
    pushId: '',
    subtitle: '',
    summary: '',
    title: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/google');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  customJson: '',
  messageId: '',
  pushId: '',
  subtitle: '',
  summary: '',
  title: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/google',
  headers: {'content-type': 'application/json'},
  data: {
    customJson: '',
    messageId: '',
    pushId: '',
    subtitle: '',
    summary: '',
    title: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/google';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"customJson":"","messageId":"","pushId":"","subtitle":"","summary":"","title":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"customJson": @"",
                              @"messageId": @"",
                              @"pushId": @"",
                              @"subtitle": @"",
                              @"summary": @"",
                              @"title": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/google"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/google" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/google",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'customJson' => '',
    'messageId' => '',
    'pushId' => '',
    'subtitle' => '',
    'summary' => '',
    'title' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/google', [
  'body' => '{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/google');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'customJson' => '',
  'messageId' => '',
  'pushId' => '',
  'subtitle' => '',
  'summary' => '',
  'title' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'customJson' => '',
  'messageId' => '',
  'pushId' => '',
  'subtitle' => '',
  'summary' => '',
  'title' => ''
]));
$request->setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/google');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/google' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/google' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/restv2/game/:apiKey/admin/pushNotifications/test/google", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/google"

payload = {
    "customJson": "",
    "messageId": "",
    "pushId": "",
    "subtitle": "",
    "summary": "",
    "title": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/google"

payload <- "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/google")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/restv2/game/:apiKey/admin/pushNotifications/test/google') do |req|
  req.body = "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/google";

    let payload = json!({
        "customJson": "",
        "messageId": "",
        "pushId": "",
        "subtitle": "",
        "summary": "",
        "title": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}' |  \
  http POST {{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/google \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "customJson": "",\n  "messageId": "",\n  "pushId": "",\n  "subtitle": "",\n  "summary": "",\n  "title": ""\n}' \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/google

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/google")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration" {:content-type :json
                                                                                                               :form-params {:customJson ""
                                                                                                                             :messageId ""
                                                                                                                             :pushId ""
                                                                                                                             :subtitle ""
                                                                                                                             :summary ""
                                                                                                                             :title ""}})

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration"),
    Content = new StringContent("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration"

	payload := strings.NewReader("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 107

{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration")
  .header("content-type", "application/json")
  .body("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  customJson: '',
  messageId: '',
  pushId: '',
  subtitle: '',
  summary: '',
  title: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration',
  headers: {'content-type': 'application/json'},
  data: {
    customJson: '',
    messageId: '',
    pushId: '',
    subtitle: '',
    summary: '',
    title: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"customJson":"","messageId":"","pushId":"","subtitle":"","summary":"","title":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "customJson": "",\n  "messageId": "",\n  "pushId": "",\n  "subtitle": "",\n  "summary": "",\n  "title": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  customJson: '',
  messageId: '',
  pushId: '',
  subtitle: '',
  summary: '',
  title: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration',
  headers: {'content-type': 'application/json'},
  body: {
    customJson: '',
    messageId: '',
    pushId: '',
    subtitle: '',
    summary: '',
    title: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  customJson: '',
  messageId: '',
  pushId: '',
  subtitle: '',
  summary: '',
  title: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration',
  headers: {'content-type': 'application/json'},
  data: {
    customJson: '',
    messageId: '',
    pushId: '',
    subtitle: '',
    summary: '',
    title: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"customJson":"","messageId":"","pushId":"","subtitle":"","summary":"","title":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"customJson": @"",
                              @"messageId": @"",
                              @"pushId": @"",
                              @"subtitle": @"",
                              @"summary": @"",
                              @"title": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'customJson' => '',
    'messageId' => '',
    'pushId' => '',
    'subtitle' => '',
    'summary' => '',
    'title' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration', [
  'body' => '{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'customJson' => '',
  'messageId' => '',
  'pushId' => '',
  'subtitle' => '',
  'summary' => '',
  'title' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'customJson' => '',
  'messageId' => '',
  'pushId' => '',
  'subtitle' => '',
  'summary' => '',
  'title' => ''
]));
$request->setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration"

payload = {
    "customJson": "",
    "messageId": "",
    "pushId": "",
    "subtitle": "",
    "summary": "",
    "title": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration"

payload <- "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration') do |req|
  req.body = "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration";

    let payload = json!({
        "customJson": "",
        "messageId": "",
        "pushId": "",
        "subtitle": "",
        "summary": "",
        "title": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}' |  \
  http POST {{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "customJson": "",\n  "messageId": "",\n  "pushId": "",\n  "subtitle": "",\n  "summary": "",\n  "title": ""\n}' \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/integration")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/production");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/production" {:content-type :json
                                                                                                              :form-params {:customJson ""
                                                                                                                            :messageId ""
                                                                                                                            :pushId ""
                                                                                                                            :subtitle ""
                                                                                                                            :summary ""
                                                                                                                            :title ""}})

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/production"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/production"),
    Content = new StringContent("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/production");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/production"

	payload := strings.NewReader("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/restv2/game/:apiKey/admin/pushNotifications/test/viber/production HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 107

{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/production")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/production"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/production")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/production")
  .header("content-type", "application/json")
  .body("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  customJson: '',
  messageId: '',
  pushId: '',
  subtitle: '',
  summary: '',
  title: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/production');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/production',
  headers: {'content-type': 'application/json'},
  data: {
    customJson: '',
    messageId: '',
    pushId: '',
    subtitle: '',
    summary: '',
    title: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/production';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"customJson":"","messageId":"","pushId":"","subtitle":"","summary":"","title":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/production',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "customJson": "",\n  "messageId": "",\n  "pushId": "",\n  "subtitle": "",\n  "summary": "",\n  "title": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/production")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/admin/pushNotifications/test/viber/production',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  customJson: '',
  messageId: '',
  pushId: '',
  subtitle: '',
  summary: '',
  title: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/production',
  headers: {'content-type': 'application/json'},
  body: {
    customJson: '',
    messageId: '',
    pushId: '',
    subtitle: '',
    summary: '',
    title: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/production');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  customJson: '',
  messageId: '',
  pushId: '',
  subtitle: '',
  summary: '',
  title: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/production',
  headers: {'content-type': 'application/json'},
  data: {
    customJson: '',
    messageId: '',
    pushId: '',
    subtitle: '',
    summary: '',
    title: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/production';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"customJson":"","messageId":"","pushId":"","subtitle":"","summary":"","title":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"customJson": @"",
                              @"messageId": @"",
                              @"pushId": @"",
                              @"subtitle": @"",
                              @"summary": @"",
                              @"title": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/production"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/production" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/production",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'customJson' => '',
    'messageId' => '',
    'pushId' => '',
    'subtitle' => '',
    'summary' => '',
    'title' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/production', [
  'body' => '{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/production');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'customJson' => '',
  'messageId' => '',
  'pushId' => '',
  'subtitle' => '',
  'summary' => '',
  'title' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'customJson' => '',
  'messageId' => '',
  'pushId' => '',
  'subtitle' => '',
  'summary' => '',
  'title' => ''
]));
$request->setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/production');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/production' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/production' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/restv2/game/:apiKey/admin/pushNotifications/test/viber/production", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/production"

payload = {
    "customJson": "",
    "messageId": "",
    "pushId": "",
    "subtitle": "",
    "summary": "",
    "title": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/production"

payload <- "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/production")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/restv2/game/:apiKey/admin/pushNotifications/test/viber/production') do |req|
  req.body = "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/production";

    let payload = json!({
        "customJson": "",
        "messageId": "",
        "pushId": "",
        "subtitle": "",
        "summary": "",
        "title": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}' |  \
  http POST {{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/production \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "customJson": "",\n  "messageId": "",\n  "pushId": "",\n  "subtitle": "",\n  "summary": "",\n  "title": ""\n}' \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/production

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/viber/production")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8" {:content-type :json
                                                                                                                :form-params {:customJson ""
                                                                                                                              :messageId ""
                                                                                                                              :pushId ""
                                                                                                                              :subtitle ""
                                                                                                                              :summary ""
                                                                                                                              :title ""}})

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8"),
    Content = new StringContent("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8"

	payload := strings.NewReader("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8 HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 107

{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8")
  .header("content-type", "application/json")
  .body("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  customJson: '',
  messageId: '',
  pushId: '',
  subtitle: '',
  summary: '',
  title: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8',
  headers: {'content-type': 'application/json'},
  data: {
    customJson: '',
    messageId: '',
    pushId: '',
    subtitle: '',
    summary: '',
    title: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"customJson":"","messageId":"","pushId":"","subtitle":"","summary":"","title":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "customJson": "",\n  "messageId": "",\n  "pushId": "",\n  "subtitle": "",\n  "summary": "",\n  "title": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  customJson: '',
  messageId: '',
  pushId: '',
  subtitle: '',
  summary: '',
  title: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8',
  headers: {'content-type': 'application/json'},
  body: {
    customJson: '',
    messageId: '',
    pushId: '',
    subtitle: '',
    summary: '',
    title: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  customJson: '',
  messageId: '',
  pushId: '',
  subtitle: '',
  summary: '',
  title: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8',
  headers: {'content-type': 'application/json'},
  data: {
    customJson: '',
    messageId: '',
    pushId: '',
    subtitle: '',
    summary: '',
    title: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"customJson":"","messageId":"","pushId":"","subtitle":"","summary":"","title":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"customJson": @"",
                              @"messageId": @"",
                              @"pushId": @"",
                              @"subtitle": @"",
                              @"summary": @"",
                              @"title": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'customJson' => '',
    'messageId' => '',
    'pushId' => '',
    'subtitle' => '',
    'summary' => '',
    'title' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8', [
  'body' => '{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'customJson' => '',
  'messageId' => '',
  'pushId' => '',
  'subtitle' => '',
  'summary' => '',
  'title' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'customJson' => '',
  'messageId' => '',
  'pushId' => '',
  'subtitle' => '',
  'summary' => '',
  'title' => ''
]));
$request->setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8"

payload = {
    "customJson": "",
    "messageId": "",
    "pushId": "",
    "subtitle": "",
    "summary": "",
    "title": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8"

payload <- "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8') do |req|
  req.body = "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8";

    let payload = json!({
        "customJson": "",
        "messageId": "",
        "pushId": "",
        "subtitle": "",
        "summary": "",
        "title": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}' |  \
  http POST {{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8 \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "customJson": "",\n  "messageId": "",\n  "pushId": "",\n  "subtitle": "",\n  "summary": "",\n  "title": ""\n}' \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windows8")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8" {:content-type :json
                                                                                                                     :form-params {:customJson ""
                                                                                                                                   :messageId ""
                                                                                                                                   :pushId ""
                                                                                                                                   :subtitle ""
                                                                                                                                   :summary ""
                                                                                                                                   :title ""}})

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8"),
    Content = new StringContent("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8"

	payload := strings.NewReader("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8 HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 107

{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8")
  .header("content-type", "application/json")
  .body("{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  customJson: '',
  messageId: '',
  pushId: '',
  subtitle: '',
  summary: '',
  title: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8',
  headers: {'content-type': 'application/json'},
  data: {
    customJson: '',
    messageId: '',
    pushId: '',
    subtitle: '',
    summary: '',
    title: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"customJson":"","messageId":"","pushId":"","subtitle":"","summary":"","title":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "customJson": "",\n  "messageId": "",\n  "pushId": "",\n  "subtitle": "",\n  "summary": "",\n  "title": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  customJson: '',
  messageId: '',
  pushId: '',
  subtitle: '',
  summary: '',
  title: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8',
  headers: {'content-type': 'application/json'},
  body: {
    customJson: '',
    messageId: '',
    pushId: '',
    subtitle: '',
    summary: '',
    title: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  customJson: '',
  messageId: '',
  pushId: '',
  subtitle: '',
  summary: '',
  title: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8',
  headers: {'content-type': 'application/json'},
  data: {
    customJson: '',
    messageId: '',
    pushId: '',
    subtitle: '',
    summary: '',
    title: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"customJson":"","messageId":"","pushId":"","subtitle":"","summary":"","title":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"customJson": @"",
                              @"messageId": @"",
                              @"pushId": @"",
                              @"subtitle": @"",
                              @"summary": @"",
                              @"title": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'customJson' => '',
    'messageId' => '',
    'pushId' => '',
    'subtitle' => '',
    'summary' => '',
    'title' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8', [
  'body' => '{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'customJson' => '',
  'messageId' => '',
  'pushId' => '',
  'subtitle' => '',
  'summary' => '',
  'title' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'customJson' => '',
  'messageId' => '',
  'pushId' => '',
  'subtitle' => '',
  'summary' => '',
  'title' => ''
]));
$request->setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8"

payload = {
    "customJson": "",
    "messageId": "",
    "pushId": "",
    "subtitle": "",
    "summary": "",
    "title": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8"

payload <- "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8') do |req|
  req.body = "{\n  \"customJson\": \"\",\n  \"messageId\": \"\",\n  \"pushId\": \"\",\n  \"subtitle\": \"\",\n  \"summary\": \"\",\n  \"title\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8";

    let payload = json!({
        "customJson": "",
        "messageId": "",
        "pushId": "",
        "subtitle": "",
        "summary": "",
        "title": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
}' |  \
  http POST {{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8 \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "customJson": "",\n  "messageId": "",\n  "pushId": "",\n  "subtitle": "",\n  "summary": "",\n  "title": ""\n}' \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "customJson": "",
  "messageId": "",
  "pushId": "",
  "subtitle": "",
  "summary": "",
  "title": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/admin/pushNotifications/test/microsoft/windowsPhone8")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:gameApiKey/regions");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restv2/game/:gameApiKey/regions")

require "http/client"

url = "{{baseUrl}}/restv2/game/:gameApiKey/regions"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:gameApiKey/regions"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:gameApiKey/regions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:gameApiKey/regions"

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

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

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

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

}

GET /baseUrl/restv2/game/:gameApiKey/regions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restv2/game/:gameApiKey/regions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:gameApiKey/regions"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:gameApiKey/regions")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restv2/game/:gameApiKey/regions")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/restv2/game/:gameApiKey/regions');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:gameApiKey/regions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:gameApiKey/regions';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:gameApiKey/regions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:gameApiKey/regions")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:gameApiKey/regions',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:gameApiKey/regions'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restv2/game/:gameApiKey/regions');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:gameApiKey/regions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:gameApiKey/regions';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:gameApiKey/regions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:gameApiKey/regions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:gameApiKey/regions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/restv2/game/:gameApiKey/regions');

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:gameApiKey/regions');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restv2/game/:gameApiKey/regions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:gameApiKey/regions' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:gameApiKey/regions' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restv2/game/:gameApiKey/regions")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:gameApiKey/regions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:gameApiKey/regions"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:gameApiKey/regions")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/restv2/game/:gameApiKey/regions') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:gameApiKey/regions";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/restv2/game/:gameApiKey/regions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restv2/game/:gameApiKey/regions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:gameApiKey/regions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/regions");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restv2/game/regions")

require "http/client"

url = "{{baseUrl}}/restv2/game/regions"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/regions"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/regions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/regions"

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

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

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

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

}

GET /baseUrl/restv2/game/regions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restv2/game/regions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/regions"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/regions")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restv2/game/regions")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/restv2/game/regions');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/restv2/game/regions'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/regions';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/regions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/regions")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/regions',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/restv2/game/regions'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restv2/game/regions');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/restv2/game/regions'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/regions';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/regions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/regions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/regions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/restv2/game/regions');

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/regions');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restv2/game/regions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/regions' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/regions' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restv2/game/regions")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/regions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/regions"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/regions")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/restv2/game/regions') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/regions";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/restv2/game/regions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restv2/game/regions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/regions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:gameApiKey/region/:regionCode");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/restv2/game/:gameApiKey/region/:regionCode")

require "http/client"

url = "{{baseUrl}}/restv2/game/:gameApiKey/region/:regionCode"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:gameApiKey/region/:regionCode"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:gameApiKey/region/:regionCode");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:gameApiKey/region/:regionCode"

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

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

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

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

}

POST /baseUrl/restv2/game/:gameApiKey/region/:regionCode HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/restv2/game/:gameApiKey/region/:regionCode")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:gameApiKey/region/:regionCode"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:gameApiKey/region/:regionCode")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/restv2/game/:gameApiKey/region/:regionCode")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/restv2/game/:gameApiKey/region/:regionCode');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:gameApiKey/region/:regionCode'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:gameApiKey/region/:regionCode';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:gameApiKey/region/:regionCode',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:gameApiKey/region/:regionCode")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:gameApiKey/region/:regionCode',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:gameApiKey/region/:regionCode'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/restv2/game/:gameApiKey/region/:regionCode');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restv2/game/:gameApiKey/region/:regionCode'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:gameApiKey/region/:regionCode';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:gameApiKey/region/:regionCode"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:gameApiKey/region/:regionCode" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:gameApiKey/region/:regionCode",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/restv2/game/:gameApiKey/region/:regionCode');

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:gameApiKey/region/:regionCode');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restv2/game/:gameApiKey/region/:regionCode');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:gameApiKey/region/:regionCode' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:gameApiKey/region/:regionCode' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/restv2/game/:gameApiKey/region/:regionCode")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:gameApiKey/region/:regionCode"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:gameApiKey/region/:regionCode"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:gameApiKey/region/:regionCode")

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

request = Net::HTTP::Post.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/restv2/game/:gameApiKey/region/:regionCode') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:gameApiKey/region/:regionCode";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/restv2/game/:gameApiKey/region/:regionCode

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/restv2/game/:gameApiKey/region/:regionCode

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:gameApiKey/region/:regionCode")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/export");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/export")

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/export"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/admin/scripts/export"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/admin/scripts/export");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/export"

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

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

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

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

}

GET /baseUrl/restv2/game/:apiKey/admin/scripts/export HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/export")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/admin/scripts/export"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/admin/scripts/export")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restv2/game/:apiKey/admin/scripts/export")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/export');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/export'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/export';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/export',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/admin/scripts/export")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/admin/scripts/export',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/export'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/export');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/export'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/export';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/admin/scripts/export"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/export" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/export",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/export');

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/admin/scripts/export');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/admin/scripts/export');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/export' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/export' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restv2/game/:apiKey/admin/scripts/export")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/export"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/export"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/admin/scripts/export")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/restv2/game/:apiKey/admin/scripts/export') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/export";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/restv2/game/:apiKey/admin/scripts/export

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/admin/scripts/export

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/export")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2")

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2"

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

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

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

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

}

GET /baseUrl/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2 HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2');

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/differences/:snapshotId1/:snapshotId2")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions/:page");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions/:page")

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions/:page"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions/:page"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions/:page");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions/:page"

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

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

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

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

}

GET /baseUrl/restv2/game/:apiKey/admin/scripts/versions/:page HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions/:page")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions/:page"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions/:page")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions/:page")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions/:page');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions/:page'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions/:page';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions/:page',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions/:page")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/admin/scripts/versions/:page',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions/:page'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions/:page');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions/:page'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions/:page';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions/:page"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions/:page" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions/:page",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions/:page');

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions/:page');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions/:page');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions/:page' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions/:page' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restv2/game/:apiKey/admin/scripts/versions/:page")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions/:page"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions/:page"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions/:page")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/restv2/game/:apiKey/admin/scripts/versions/:page') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions/:page";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions/:page

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions/:page

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions/:page")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions")

require "http/client"

url = "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions"

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

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

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

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

}

GET /baseUrl/restv2/game/:apiKey/admin/scripts/versions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restv2/game/:apiKey/admin/scripts/versions',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions');

echo $response->getBody();

setUrl('{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restv2/game/:apiKey/admin/scripts/versions")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/restv2/game/:apiKey/admin/scripts/versions') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restv2/game/:apiKey/admin/scripts/versions";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}