CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin.apps.approve");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "token: ");
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "app_id=&request_id=&team_id=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/admin.apps.approve" {:headers {:token ""}
                                                               :form-params {:app_id ""
                                                                             :request_id ""
                                                                             :team_id ""}})

require "http/client"

url = "{{baseUrl}}/admin.apps.approve"
headers = HTTP::Headers{
  "token" => ""
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "app_id=&request_id=&team_id="

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}}/admin.apps.approve"),
    Headers =
    {
        { "token", "" },
    },
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "app_id", "" },
        { "request_id", "" },
        { "team_id", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.apps.approve");
var request = new RestRequest("", Method.Post);
request.AddHeader("token", "");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "app_id=&request_id=&team_id=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin.apps.approve"

	payload := strings.NewReader("app_id=&request_id=&team_id=")

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

	req.Header.Add("token", "")
	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}

POST /baseUrl/admin.apps.approve HTTP/1.1
Token: 
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 28

app_id=&request_id=&team_id=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin.apps.approve")
  .setHeader("token", "")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("app_id=&request_id=&team_id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.apps.approve"))
    .header("token", "")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("app_id=&request_id=&team_id="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "app_id=&request_id=&team_id=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin.apps.approve")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin.apps.approve")
  .header("token", "")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("app_id=&request_id=&team_id=")
  .asString();

const data = 'app_id=&request_id=&team_id=';

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

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

xhr.open('POST', '{{baseUrl}}/admin.apps.approve');
xhr.setRequestHeader('token', '');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('app_id', '');
encodedParams.set('request_id', '');
encodedParams.set('team_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.apps.approve',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/admin.apps.approve';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({app_id: '', request_id: '', team_id: ''})
};

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}}/admin.apps.approve',
  method: 'POST',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    app_id: '',
    request_id: '',
    team_id: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "app_id=&request_id=&team_id=")
val request = Request.Builder()
  .url("{{baseUrl}}/admin.apps.approve")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.apps.approve',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({app_id: '', request_id: '', team_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.apps.approve',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  form: {app_id: '', request_id: '', team_id: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/admin.apps.approve');

req.headers({
  token: '',
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  app_id: '',
  request_id: '',
  team_id: ''
});

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

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

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('app_id', '');
encodedParams.set('request_id', '');
encodedParams.set('team_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.apps.approve',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('app_id', '');
encodedParams.set('request_id', '');
encodedParams.set('team_id', '');

const url = '{{baseUrl}}/admin.apps.approve';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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

#import 

NSDictionary *headers = @{ @"token": @"",
                           @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"app_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&request_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&team_id=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin.apps.approve"]
                                                       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}}/admin.apps.approve" in
let headers = Header.add_list (Header.init ()) [
  ("token", "");
  ("content-type", "application/x-www-form-urlencoded");
] in
let body = Cohttp_lwt_body.of_string "app_id=&request_id=&team_id=" in

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

 "{{baseUrl}}/admin.apps.approve",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "app_id=&request_id=&team_id=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "token: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/admin.apps.approve', [
  'form_params' => [
    'app_id' => '',
    'request_id' => '',
    'team_id' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin.apps.approve');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'app_id' => '',
  'request_id' => '',
  'team_id' => ''
]);

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

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

append(new http\QueryString([
  'app_id' => '',
  'request_id' => '',
  'team_id' => ''
]));

$request->setRequestUrl('{{baseUrl}}/admin.apps.approve');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.apps.approve' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'app_id=&request_id=&team_id='

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.apps.approve' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'app_id=&request_id=&team_id='

import http.client

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

payload = "app_id=&request_id=&team_id="

headers = {
    'token': "",
    'content-type': "application/x-www-form-urlencoded"
}

conn.request("POST", "/baseUrl/admin.apps.approve", payload, headers)

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

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

import requests

url = "{{baseUrl}}/admin.apps.approve"

payload = {
    "app_id": "",
    "request_id": "",
    "team_id": ""
}
headers = {
    "token": "",
    "content-type": "application/x-www-form-urlencoded"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.apps.approve"

payload <- "app_id=&request_id=&team_id="

encode <- "form"

response <- VERB("POST", url, body = payload, add_headers('token' = ''), content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.apps.approve")

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

request = Net::HTTP::Post.new(url)
request["token"] = ''
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "app_id=&request_id=&team_id="

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

require 'faraday'

data = {
  :app_id => "",
  :request_id => "",
  :team_id => "",
}

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

response = conn.post('/baseUrl/admin.apps.approve') do |req|
  req.headers['token'] = ''
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.apps.approve";

    let payload = json!({
        "app_id": "",
        "request_id": "",
        "team_id": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("token", "".parse().unwrap());
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/admin.apps.approve \
  content-type:application/x-www-form-urlencoded \
  token:'' \
  app_id='' \
  request_id='' \
  team_id=''

wget --quiet \
  --method POST \
  --header 'token: ' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'app_id=&request_id=&team_id=' \
  --output-document \
  - {{baseUrl}}/admin.apps.approve

import Foundation

let headers = [
  "token": "",
  "content-type": "application/x-www-form-urlencoded"
]

let postData = NSMutableData(data: "app_id=".data(using: String.Encoding.utf8)!)
postData.append("&request_id=".data(using: String.Encoding.utf8)!)
postData.append("&team_id=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.apps.approve")! 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}}/admin.apps.restrict");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "token: ");
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "app_id=&request_id=&team_id=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/admin.apps.restrict" {:headers {:token ""}
                                                                :form-params {:app_id ""
                                                                              :request_id ""
                                                                              :team_id ""}})

require "http/client"

url = "{{baseUrl}}/admin.apps.restrict"
headers = HTTP::Headers{
  "token" => ""
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "app_id=&request_id=&team_id="

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}}/admin.apps.restrict"),
    Headers =
    {
        { "token", "" },
    },
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "app_id", "" },
        { "request_id", "" },
        { "team_id", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.apps.restrict");
var request = new RestRequest("", Method.Post);
request.AddHeader("token", "");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "app_id=&request_id=&team_id=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin.apps.restrict"

	payload := strings.NewReader("app_id=&request_id=&team_id=")

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

	req.Header.Add("token", "")
	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}

POST /baseUrl/admin.apps.restrict HTTP/1.1
Token: 
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 28

app_id=&request_id=&team_id=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin.apps.restrict")
  .setHeader("token", "")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("app_id=&request_id=&team_id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.apps.restrict"))
    .header("token", "")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("app_id=&request_id=&team_id="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "app_id=&request_id=&team_id=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin.apps.restrict")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin.apps.restrict")
  .header("token", "")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("app_id=&request_id=&team_id=")
  .asString();

const data = 'app_id=&request_id=&team_id=';

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

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

xhr.open('POST', '{{baseUrl}}/admin.apps.restrict');
xhr.setRequestHeader('token', '');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('app_id', '');
encodedParams.set('request_id', '');
encodedParams.set('team_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.apps.restrict',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/admin.apps.restrict';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({app_id: '', request_id: '', team_id: ''})
};

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}}/admin.apps.restrict',
  method: 'POST',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    app_id: '',
    request_id: '',
    team_id: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "app_id=&request_id=&team_id=")
val request = Request.Builder()
  .url("{{baseUrl}}/admin.apps.restrict")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.apps.restrict',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({app_id: '', request_id: '', team_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.apps.restrict',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  form: {app_id: '', request_id: '', team_id: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/admin.apps.restrict');

req.headers({
  token: '',
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  app_id: '',
  request_id: '',
  team_id: ''
});

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

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

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('app_id', '');
encodedParams.set('request_id', '');
encodedParams.set('team_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.apps.restrict',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('app_id', '');
encodedParams.set('request_id', '');
encodedParams.set('team_id', '');

const url = '{{baseUrl}}/admin.apps.restrict';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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

#import 

NSDictionary *headers = @{ @"token": @"",
                           @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"app_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&request_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&team_id=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin.apps.restrict"]
                                                       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}}/admin.apps.restrict" in
let headers = Header.add_list (Header.init ()) [
  ("token", "");
  ("content-type", "application/x-www-form-urlencoded");
] in
let body = Cohttp_lwt_body.of_string "app_id=&request_id=&team_id=" in

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

 "{{baseUrl}}/admin.apps.restrict",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "app_id=&request_id=&team_id=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "token: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/admin.apps.restrict', [
  'form_params' => [
    'app_id' => '',
    'request_id' => '',
    'team_id' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin.apps.restrict');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'app_id' => '',
  'request_id' => '',
  'team_id' => ''
]);

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

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

append(new http\QueryString([
  'app_id' => '',
  'request_id' => '',
  'team_id' => ''
]));

$request->setRequestUrl('{{baseUrl}}/admin.apps.restrict');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.apps.restrict' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'app_id=&request_id=&team_id='

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.apps.restrict' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'app_id=&request_id=&team_id='

import http.client

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

payload = "app_id=&request_id=&team_id="

headers = {
    'token': "",
    'content-type': "application/x-www-form-urlencoded"
}

conn.request("POST", "/baseUrl/admin.apps.restrict", payload, headers)

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

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

import requests

url = "{{baseUrl}}/admin.apps.restrict"

payload = {
    "app_id": "",
    "request_id": "",
    "team_id": ""
}
headers = {
    "token": "",
    "content-type": "application/x-www-form-urlencoded"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.apps.restrict"

payload <- "app_id=&request_id=&team_id="

encode <- "form"

response <- VERB("POST", url, body = payload, add_headers('token' = ''), content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.apps.restrict")

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

request = Net::HTTP::Post.new(url)
request["token"] = ''
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "app_id=&request_id=&team_id="

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

require 'faraday'

data = {
  :app_id => "",
  :request_id => "",
  :team_id => "",
}

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

response = conn.post('/baseUrl/admin.apps.restrict') do |req|
  req.headers['token'] = ''
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.apps.restrict";

    let payload = json!({
        "app_id": "",
        "request_id": "",
        "team_id": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("token", "".parse().unwrap());
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/admin.apps.restrict \
  content-type:application/x-www-form-urlencoded \
  token:'' \
  app_id='' \
  request_id='' \
  team_id=''

wget --quiet \
  --method POST \
  --header 'token: ' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'app_id=&request_id=&team_id=' \
  --output-document \
  - {{baseUrl}}/admin.apps.restrict

import Foundation

let headers = [
  "token": "",
  "content-type": "application/x-www-form-urlencoded"
]

let postData = NSMutableData(data: "app_id=".data(using: String.Encoding.utf8)!)
postData.append("&request_id=".data(using: String.Encoding.utf8)!)
postData.append("&team_id=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.apps.restrict")! 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}}/admin.apps.approved.list?token=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/admin.apps.approved.list" {:query-params {:token ""}})

require "http/client"

url = "{{baseUrl}}/admin.apps.approved.list?token="

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}}/admin.apps.approved.list?token="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.apps.approved.list?token=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin.apps.approved.list?token="

	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/admin.apps.approved.list?token= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin.apps.approved.list?token=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.apps.approved.list?token="))
    .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}}/admin.apps.approved.list?token=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/admin.apps.approved.list?token=")
  .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}}/admin.apps.approved.list?token=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin.apps.approved.list',
  params: {token: ''}
};

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

const url = '{{baseUrl}}/admin.apps.approved.list?token=';
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}}/admin.apps.approved.list?token=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin.apps.approved.list?token=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.apps.approved.list?token=',
  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}}/admin.apps.approved.list',
  qs: {token: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/admin.apps.approved.list');

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

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}}/admin.apps.approved.list',
  params: {token: ''}
};

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

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

const url = '{{baseUrl}}/admin.apps.approved.list?token=';
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}}/admin.apps.approved.list?token="]
                                                       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}}/admin.apps.approved.list?token=" in

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

 "{{baseUrl}}/admin.apps.approved.list?token=",
  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}}/admin.apps.approved.list?token=');

echo $response->getBody();

setUrl('{{baseUrl}}/admin.apps.approved.list');
$request->setMethod(HTTP_METH_GET);

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

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

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

setRequestUrl('{{baseUrl}}/admin.apps.approved.list');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'token' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.apps.approved.list?token=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.apps.approved.list?token=' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/admin.apps.approved.list?token=")

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

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

import requests

url = "{{baseUrl}}/admin.apps.approved.list"

querystring = {"token":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.apps.approved.list"

queryString <- list(token = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.apps.approved.list?token=")

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/admin.apps.approved.list') do |req|
  req.params['token'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.apps.approved.list";

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

    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}}/admin.apps.approved.list?token='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/admin.apps.approved.list?token='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.apps.approved.list?token=")! 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}}/admin.apps.requests.list?token=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/admin.apps.requests.list" {:query-params {:token ""}})

require "http/client"

url = "{{baseUrl}}/admin.apps.requests.list?token="

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}}/admin.apps.requests.list?token="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.apps.requests.list?token=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin.apps.requests.list?token="

	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/admin.apps.requests.list?token= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin.apps.requests.list?token=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.apps.requests.list?token="))
    .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}}/admin.apps.requests.list?token=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/admin.apps.requests.list?token=")
  .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}}/admin.apps.requests.list?token=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin.apps.requests.list',
  params: {token: ''}
};

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

const url = '{{baseUrl}}/admin.apps.requests.list?token=';
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}}/admin.apps.requests.list?token=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin.apps.requests.list?token=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.apps.requests.list?token=',
  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}}/admin.apps.requests.list',
  qs: {token: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/admin.apps.requests.list');

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

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}}/admin.apps.requests.list',
  params: {token: ''}
};

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

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

const url = '{{baseUrl}}/admin.apps.requests.list?token=';
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}}/admin.apps.requests.list?token="]
                                                       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}}/admin.apps.requests.list?token=" in

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

 "{{baseUrl}}/admin.apps.requests.list?token=",
  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}}/admin.apps.requests.list?token=');

echo $response->getBody();

setUrl('{{baseUrl}}/admin.apps.requests.list');
$request->setMethod(HTTP_METH_GET);

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

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

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

setRequestUrl('{{baseUrl}}/admin.apps.requests.list');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'token' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.apps.requests.list?token=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.apps.requests.list?token=' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/admin.apps.requests.list?token=")

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

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

import requests

url = "{{baseUrl}}/admin.apps.requests.list"

querystring = {"token":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.apps.requests.list"

queryString <- list(token = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.apps.requests.list?token=")

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/admin.apps.requests.list') do |req|
  req.params['token'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.apps.requests.list";

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

    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}}/admin.apps.requests.list?token='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/admin.apps.requests.list?token='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.apps.requests.list?token=")! 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}}/admin.apps.restricted.list?token=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/admin.apps.restricted.list" {:query-params {:token ""}})

require "http/client"

url = "{{baseUrl}}/admin.apps.restricted.list?token="

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}}/admin.apps.restricted.list?token="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.apps.restricted.list?token=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin.apps.restricted.list?token="

	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/admin.apps.restricted.list?token= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin.apps.restricted.list?token=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.apps.restricted.list?token="))
    .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}}/admin.apps.restricted.list?token=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/admin.apps.restricted.list?token=")
  .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}}/admin.apps.restricted.list?token=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin.apps.restricted.list',
  params: {token: ''}
};

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

const url = '{{baseUrl}}/admin.apps.restricted.list?token=';
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}}/admin.apps.restricted.list?token=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin.apps.restricted.list?token=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.apps.restricted.list?token=',
  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}}/admin.apps.restricted.list',
  qs: {token: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/admin.apps.restricted.list');

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

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}}/admin.apps.restricted.list',
  params: {token: ''}
};

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

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

const url = '{{baseUrl}}/admin.apps.restricted.list?token=';
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}}/admin.apps.restricted.list?token="]
                                                       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}}/admin.apps.restricted.list?token=" in

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

 "{{baseUrl}}/admin.apps.restricted.list?token=",
  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}}/admin.apps.restricted.list?token=');

echo $response->getBody();

setUrl('{{baseUrl}}/admin.apps.restricted.list');
$request->setMethod(HTTP_METH_GET);

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

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

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

setRequestUrl('{{baseUrl}}/admin.apps.restricted.list');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'token' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.apps.restricted.list?token=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.apps.restricted.list?token=' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/admin.apps.restricted.list?token=")

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

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

import requests

url = "{{baseUrl}}/admin.apps.restricted.list"

querystring = {"token":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.apps.restricted.list"

queryString <- list(token = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.apps.restricted.list?token=")

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/admin.apps.restricted.list') do |req|
  req.params['token'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.apps.restricted.list";

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

    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}}/admin.apps.restricted.list?token='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/admin.apps.restricted.list?token='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.apps.restricted.list?token=")! 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}}/admin.conversations.archive");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "token: ");
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "channel_id=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/admin.conversations.archive" {:headers {:token ""}
                                                                        :form-params {:channel_id ""}})

require "http/client"

url = "{{baseUrl}}/admin.conversations.archive"
headers = HTTP::Headers{
  "token" => ""
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "channel_id="

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}}/admin.conversations.archive"),
    Headers =
    {
        { "token", "" },
    },
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "channel_id", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.conversations.archive");
var request = new RestRequest("", Method.Post);
request.AddHeader("token", "");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "channel_id=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin.conversations.archive"

	payload := strings.NewReader("channel_id=")

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

	req.Header.Add("token", "")
	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}

POST /baseUrl/admin.conversations.archive HTTP/1.1
Token: 
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 11

channel_id=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin.conversations.archive")
  .setHeader("token", "")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("channel_id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.conversations.archive"))
    .header("token", "")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("channel_id="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "channel_id=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin.conversations.archive")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin.conversations.archive")
  .header("token", "")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("channel_id=")
  .asString();

const data = 'channel_id=';

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

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

xhr.open('POST', '{{baseUrl}}/admin.conversations.archive');
xhr.setRequestHeader('token', '');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('channel_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.conversations.archive',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/admin.conversations.archive';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({channel_id: ''})
};

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}}/admin.conversations.archive',
  method: 'POST',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    channel_id: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "channel_id=")
val request = Request.Builder()
  .url("{{baseUrl}}/admin.conversations.archive")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.conversations.archive',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({channel_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.conversations.archive',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  form: {channel_id: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/admin.conversations.archive');

req.headers({
  token: '',
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  channel_id: ''
});

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

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

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('channel_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.conversations.archive',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('channel_id', '');

const url = '{{baseUrl}}/admin.conversations.archive';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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

#import 

NSDictionary *headers = @{ @"token": @"",
                           @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"channel_id=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin.conversations.archive"]
                                                       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}}/admin.conversations.archive" in
let headers = Header.add_list (Header.init ()) [
  ("token", "");
  ("content-type", "application/x-www-form-urlencoded");
] in
let body = Cohttp_lwt_body.of_string "channel_id=" in

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

 "{{baseUrl}}/admin.conversations.archive",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "channel_id=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "token: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/admin.conversations.archive', [
  'form_params' => [
    'channel_id' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin.conversations.archive');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'channel_id' => ''
]);

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

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

append(new http\QueryString([
  'channel_id' => ''
]));

$request->setRequestUrl('{{baseUrl}}/admin.conversations.archive');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.conversations.archive' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'channel_id='

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.conversations.archive' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'channel_id='

import http.client

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

payload = "channel_id="

headers = {
    'token': "",
    'content-type': "application/x-www-form-urlencoded"
}

conn.request("POST", "/baseUrl/admin.conversations.archive", payload, headers)

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

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

import requests

url = "{{baseUrl}}/admin.conversations.archive"

payload = { "channel_id": "" }
headers = {
    "token": "",
    "content-type": "application/x-www-form-urlencoded"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.conversations.archive"

payload <- "channel_id="

encode <- "form"

response <- VERB("POST", url, body = payload, add_headers('token' = ''), content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.conversations.archive")

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

request = Net::HTTP::Post.new(url)
request["token"] = ''
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "channel_id="

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

require 'faraday'

data = {
  :channel_id => "",
}

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

response = conn.post('/baseUrl/admin.conversations.archive') do |req|
  req.headers['token'] = ''
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.conversations.archive";

    let payload = json!({"channel_id": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("token", "".parse().unwrap());
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/admin.conversations.archive \
  content-type:application/x-www-form-urlencoded \
  token:'' \
  channel_id=''

wget --quiet \
  --method POST \
  --header 'token: ' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data channel_id= \
  --output-document \
  - {{baseUrl}}/admin.conversations.archive

import Foundation

let headers = [
  "token": "",
  "content-type": "application/x-www-form-urlencoded"
]

let postData = NSMutableData(data: "channel_id=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.conversations.archive")! 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}}/admin.conversations.convertToPrivate");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "token: ");
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "channel_id=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/admin.conversations.convertToPrivate" {:headers {:token ""}
                                                                                 :form-params {:channel_id ""}})

require "http/client"

url = "{{baseUrl}}/admin.conversations.convertToPrivate"
headers = HTTP::Headers{
  "token" => ""
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "channel_id="

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}}/admin.conversations.convertToPrivate"),
    Headers =
    {
        { "token", "" },
    },
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "channel_id", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.conversations.convertToPrivate");
var request = new RestRequest("", Method.Post);
request.AddHeader("token", "");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "channel_id=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin.conversations.convertToPrivate"

	payload := strings.NewReader("channel_id=")

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

	req.Header.Add("token", "")
	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}

POST /baseUrl/admin.conversations.convertToPrivate HTTP/1.1
Token: 
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 11

channel_id=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin.conversations.convertToPrivate")
  .setHeader("token", "")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("channel_id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.conversations.convertToPrivate"))
    .header("token", "")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("channel_id="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "channel_id=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin.conversations.convertToPrivate")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin.conversations.convertToPrivate")
  .header("token", "")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("channel_id=")
  .asString();

const data = 'channel_id=';

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

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

xhr.open('POST', '{{baseUrl}}/admin.conversations.convertToPrivate');
xhr.setRequestHeader('token', '');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('channel_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.conversations.convertToPrivate',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/admin.conversations.convertToPrivate';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({channel_id: ''})
};

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}}/admin.conversations.convertToPrivate',
  method: 'POST',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    channel_id: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "channel_id=")
val request = Request.Builder()
  .url("{{baseUrl}}/admin.conversations.convertToPrivate")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.conversations.convertToPrivate',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({channel_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.conversations.convertToPrivate',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  form: {channel_id: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/admin.conversations.convertToPrivate');

req.headers({
  token: '',
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  channel_id: ''
});

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

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

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('channel_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.conversations.convertToPrivate',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('channel_id', '');

const url = '{{baseUrl}}/admin.conversations.convertToPrivate';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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

#import 

NSDictionary *headers = @{ @"token": @"",
                           @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"channel_id=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin.conversations.convertToPrivate"]
                                                       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}}/admin.conversations.convertToPrivate" in
let headers = Header.add_list (Header.init ()) [
  ("token", "");
  ("content-type", "application/x-www-form-urlencoded");
] in
let body = Cohttp_lwt_body.of_string "channel_id=" in

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

 "{{baseUrl}}/admin.conversations.convertToPrivate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "channel_id=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "token: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/admin.conversations.convertToPrivate', [
  'form_params' => [
    'channel_id' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin.conversations.convertToPrivate');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'channel_id' => ''
]);

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

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

append(new http\QueryString([
  'channel_id' => ''
]));

$request->setRequestUrl('{{baseUrl}}/admin.conversations.convertToPrivate');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.conversations.convertToPrivate' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'channel_id='

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.conversations.convertToPrivate' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'channel_id='

import http.client

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

payload = "channel_id="

headers = {
    'token': "",
    'content-type': "application/x-www-form-urlencoded"
}

conn.request("POST", "/baseUrl/admin.conversations.convertToPrivate", payload, headers)

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

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

import requests

url = "{{baseUrl}}/admin.conversations.convertToPrivate"

payload = { "channel_id": "" }
headers = {
    "token": "",
    "content-type": "application/x-www-form-urlencoded"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.conversations.convertToPrivate"

payload <- "channel_id="

encode <- "form"

response <- VERB("POST", url, body = payload, add_headers('token' = ''), content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.conversations.convertToPrivate")

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

request = Net::HTTP::Post.new(url)
request["token"] = ''
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "channel_id="

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

require 'faraday'

data = {
  :channel_id => "",
}

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

response = conn.post('/baseUrl/admin.conversations.convertToPrivate') do |req|
  req.headers['token'] = ''
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.conversations.convertToPrivate";

    let payload = json!({"channel_id": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("token", "".parse().unwrap());
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/admin.conversations.convertToPrivate \
  content-type:application/x-www-form-urlencoded \
  token:'' \
  channel_id=''

wget --quiet \
  --method POST \
  --header 'token: ' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data channel_id= \
  --output-document \
  - {{baseUrl}}/admin.conversations.convertToPrivate

import Foundation

let headers = [
  "token": "",
  "content-type": "application/x-www-form-urlencoded"
]

let postData = NSMutableData(data: "channel_id=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.conversations.convertToPrivate")! 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}}/admin.conversations.create");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "token: ");
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "description=&is_private=&name=&org_wide=&team_id=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/admin.conversations.create" {:headers {:token ""}
                                                                       :form-params {:description ""
                                                                                     :is_private ""
                                                                                     :name ""
                                                                                     :org_wide ""
                                                                                     :team_id ""}})

require "http/client"

url = "{{baseUrl}}/admin.conversations.create"
headers = HTTP::Headers{
  "token" => ""
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "description=&is_private=&name=&org_wide=&team_id="

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}}/admin.conversations.create"),
    Headers =
    {
        { "token", "" },
    },
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "description", "" },
        { "is_private", "" },
        { "name", "" },
        { "org_wide", "" },
        { "team_id", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.conversations.create");
var request = new RestRequest("", Method.Post);
request.AddHeader("token", "");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "description=&is_private=&name=&org_wide=&team_id=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin.conversations.create"

	payload := strings.NewReader("description=&is_private=&name=&org_wide=&team_id=")

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

	req.Header.Add("token", "")
	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}

POST /baseUrl/admin.conversations.create HTTP/1.1
Token: 
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 49

description=&is_private=&name=&org_wide=&team_id=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin.conversations.create")
  .setHeader("token", "")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("description=&is_private=&name=&org_wide=&team_id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.conversations.create"))
    .header("token", "")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("description=&is_private=&name=&org_wide=&team_id="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "description=&is_private=&name=&org_wide=&team_id=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin.conversations.create")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin.conversations.create")
  .header("token", "")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("description=&is_private=&name=&org_wide=&team_id=")
  .asString();

const data = 'description=&is_private=&name=&org_wide=&team_id=';

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

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

xhr.open('POST', '{{baseUrl}}/admin.conversations.create');
xhr.setRequestHeader('token', '');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('description', '');
encodedParams.set('is_private', '');
encodedParams.set('name', '');
encodedParams.set('org_wide', '');
encodedParams.set('team_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.conversations.create',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/admin.conversations.create';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({description: '', is_private: '', name: '', org_wide: '', team_id: ''})
};

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}}/admin.conversations.create',
  method: 'POST',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    description: '',
    is_private: '',
    name: '',
    org_wide: '',
    team_id: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "description=&is_private=&name=&org_wide=&team_id=")
val request = Request.Builder()
  .url("{{baseUrl}}/admin.conversations.create")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.conversations.create',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({description: '', is_private: '', name: '', org_wide: '', team_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.conversations.create',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  form: {description: '', is_private: '', name: '', org_wide: '', team_id: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/admin.conversations.create');

req.headers({
  token: '',
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  description: '',
  is_private: '',
  name: '',
  org_wide: '',
  team_id: ''
});

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

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

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('description', '');
encodedParams.set('is_private', '');
encodedParams.set('name', '');
encodedParams.set('org_wide', '');
encodedParams.set('team_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.conversations.create',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('description', '');
encodedParams.set('is_private', '');
encodedParams.set('name', '');
encodedParams.set('org_wide', '');
encodedParams.set('team_id', '');

const url = '{{baseUrl}}/admin.conversations.create';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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

#import 

NSDictionary *headers = @{ @"token": @"",
                           @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"description=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&is_private=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&name=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&org_wide=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&team_id=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin.conversations.create"]
                                                       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}}/admin.conversations.create" in
let headers = Header.add_list (Header.init ()) [
  ("token", "");
  ("content-type", "application/x-www-form-urlencoded");
] in
let body = Cohttp_lwt_body.of_string "description=&is_private=&name=&org_wide=&team_id=" in

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

 "{{baseUrl}}/admin.conversations.create",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "description=&is_private=&name=&org_wide=&team_id=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "token: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/admin.conversations.create', [
  'form_params' => [
    'description' => '',
    'is_private' => '',
    'name' => '',
    'org_wide' => '',
    'team_id' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin.conversations.create');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'description' => '',
  'is_private' => '',
  'name' => '',
  'org_wide' => '',
  'team_id' => ''
]);

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

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

append(new http\QueryString([
  'description' => '',
  'is_private' => '',
  'name' => '',
  'org_wide' => '',
  'team_id' => ''
]));

$request->setRequestUrl('{{baseUrl}}/admin.conversations.create');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.conversations.create' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'description=&is_private=&name=&org_wide=&team_id='

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.conversations.create' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'description=&is_private=&name=&org_wide=&team_id='

import http.client

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

payload = "description=&is_private=&name=&org_wide=&team_id="

headers = {
    'token': "",
    'content-type': "application/x-www-form-urlencoded"
}

conn.request("POST", "/baseUrl/admin.conversations.create", payload, headers)

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

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

import requests

url = "{{baseUrl}}/admin.conversations.create"

payload = {
    "description": "",
    "is_private": "",
    "name": "",
    "org_wide": "",
    "team_id": ""
}
headers = {
    "token": "",
    "content-type": "application/x-www-form-urlencoded"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.conversations.create"

payload <- "description=&is_private=&name=&org_wide=&team_id="

encode <- "form"

response <- VERB("POST", url, body = payload, add_headers('token' = ''), content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.conversations.create")

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

request = Net::HTTP::Post.new(url)
request["token"] = ''
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "description=&is_private=&name=&org_wide=&team_id="

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

require 'faraday'

data = {
  :description => "",
  :is_private => "",
  :name => "",
  :org_wide => "",
  :team_id => "",
}

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

response = conn.post('/baseUrl/admin.conversations.create') do |req|
  req.headers['token'] = ''
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.conversations.create";

    let payload = json!({
        "description": "",
        "is_private": "",
        "name": "",
        "org_wide": "",
        "team_id": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("token", "".parse().unwrap());
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/admin.conversations.create \
  content-type:application/x-www-form-urlencoded \
  token:'' \
  description='' \
  is_private='' \
  name='' \
  org_wide='' \
  team_id=''

wget --quiet \
  --method POST \
  --header 'token: ' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'description=&is_private=&name=&org_wide=&team_id=' \
  --output-document \
  - {{baseUrl}}/admin.conversations.create

import Foundation

let headers = [
  "token": "",
  "content-type": "application/x-www-form-urlencoded"
]

let postData = NSMutableData(data: "description=".data(using: String.Encoding.utf8)!)
postData.append("&is_private=".data(using: String.Encoding.utf8)!)
postData.append("&name=".data(using: String.Encoding.utf8)!)
postData.append("&org_wide=".data(using: String.Encoding.utf8)!)
postData.append("&team_id=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.conversations.create")! 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}}/admin.conversations.delete");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "token: ");
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "channel_id=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/admin.conversations.delete" {:headers {:token ""}
                                                                       :form-params {:channel_id ""}})

require "http/client"

url = "{{baseUrl}}/admin.conversations.delete"
headers = HTTP::Headers{
  "token" => ""
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "channel_id="

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}}/admin.conversations.delete"),
    Headers =
    {
        { "token", "" },
    },
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "channel_id", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.conversations.delete");
var request = new RestRequest("", Method.Post);
request.AddHeader("token", "");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "channel_id=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin.conversations.delete"

	payload := strings.NewReader("channel_id=")

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

	req.Header.Add("token", "")
	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}

POST /baseUrl/admin.conversations.delete HTTP/1.1
Token: 
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 11

channel_id=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin.conversations.delete")
  .setHeader("token", "")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("channel_id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.conversations.delete"))
    .header("token", "")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("channel_id="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "channel_id=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin.conversations.delete")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin.conversations.delete")
  .header("token", "")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("channel_id=")
  .asString();

const data = 'channel_id=';

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

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

xhr.open('POST', '{{baseUrl}}/admin.conversations.delete');
xhr.setRequestHeader('token', '');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('channel_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.conversations.delete',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/admin.conversations.delete';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({channel_id: ''})
};

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}}/admin.conversations.delete',
  method: 'POST',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    channel_id: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "channel_id=")
val request = Request.Builder()
  .url("{{baseUrl}}/admin.conversations.delete")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.conversations.delete',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({channel_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.conversations.delete',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  form: {channel_id: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/admin.conversations.delete');

req.headers({
  token: '',
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  channel_id: ''
});

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

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

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('channel_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.conversations.delete',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('channel_id', '');

const url = '{{baseUrl}}/admin.conversations.delete';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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

#import 

NSDictionary *headers = @{ @"token": @"",
                           @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"channel_id=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin.conversations.delete"]
                                                       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}}/admin.conversations.delete" in
let headers = Header.add_list (Header.init ()) [
  ("token", "");
  ("content-type", "application/x-www-form-urlencoded");
] in
let body = Cohttp_lwt_body.of_string "channel_id=" in

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

 "{{baseUrl}}/admin.conversations.delete",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "channel_id=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "token: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/admin.conversations.delete', [
  'form_params' => [
    'channel_id' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin.conversations.delete');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'channel_id' => ''
]);

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

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

append(new http\QueryString([
  'channel_id' => ''
]));

$request->setRequestUrl('{{baseUrl}}/admin.conversations.delete');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.conversations.delete' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'channel_id='

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.conversations.delete' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'channel_id='

import http.client

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

payload = "channel_id="

headers = {
    'token': "",
    'content-type': "application/x-www-form-urlencoded"
}

conn.request("POST", "/baseUrl/admin.conversations.delete", payload, headers)

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

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

import requests

url = "{{baseUrl}}/admin.conversations.delete"

payload = { "channel_id": "" }
headers = {
    "token": "",
    "content-type": "application/x-www-form-urlencoded"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.conversations.delete"

payload <- "channel_id="

encode <- "form"

response <- VERB("POST", url, body = payload, add_headers('token' = ''), content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.conversations.delete")

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

request = Net::HTTP::Post.new(url)
request["token"] = ''
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "channel_id="

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

require 'faraday'

data = {
  :channel_id => "",
}

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

response = conn.post('/baseUrl/admin.conversations.delete') do |req|
  req.headers['token'] = ''
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.conversations.delete";

    let payload = json!({"channel_id": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("token", "".parse().unwrap());
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/admin.conversations.delete \
  content-type:application/x-www-form-urlencoded \
  token:'' \
  channel_id=''

wget --quiet \
  --method POST \
  --header 'token: ' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data channel_id= \
  --output-document \
  - {{baseUrl}}/admin.conversations.delete

import Foundation

let headers = [
  "token": "",
  "content-type": "application/x-www-form-urlencoded"
]

let postData = NSMutableData(data: "channel_id=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.conversations.delete")! 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}}/admin.conversations.disconnectShared");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "token: ");
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "channel_id=&leaving_team_ids=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/admin.conversations.disconnectShared" {:headers {:token ""}
                                                                                 :form-params {:channel_id ""
                                                                                               :leaving_team_ids ""}})

require "http/client"

url = "{{baseUrl}}/admin.conversations.disconnectShared"
headers = HTTP::Headers{
  "token" => ""
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "channel_id=&leaving_team_ids="

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}}/admin.conversations.disconnectShared"),
    Headers =
    {
        { "token", "" },
    },
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "channel_id", "" },
        { "leaving_team_ids", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.conversations.disconnectShared");
var request = new RestRequest("", Method.Post);
request.AddHeader("token", "");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "channel_id=&leaving_team_ids=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin.conversations.disconnectShared"

	payload := strings.NewReader("channel_id=&leaving_team_ids=")

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

	req.Header.Add("token", "")
	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}

POST /baseUrl/admin.conversations.disconnectShared HTTP/1.1
Token: 
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 29

channel_id=&leaving_team_ids=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin.conversations.disconnectShared")
  .setHeader("token", "")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("channel_id=&leaving_team_ids=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.conversations.disconnectShared"))
    .header("token", "")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("channel_id=&leaving_team_ids="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "channel_id=&leaving_team_ids=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin.conversations.disconnectShared")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin.conversations.disconnectShared")
  .header("token", "")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("channel_id=&leaving_team_ids=")
  .asString();

const data = 'channel_id=&leaving_team_ids=';

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

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

xhr.open('POST', '{{baseUrl}}/admin.conversations.disconnectShared');
xhr.setRequestHeader('token', '');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('channel_id', '');
encodedParams.set('leaving_team_ids', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.conversations.disconnectShared',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/admin.conversations.disconnectShared';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({channel_id: '', leaving_team_ids: ''})
};

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}}/admin.conversations.disconnectShared',
  method: 'POST',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    channel_id: '',
    leaving_team_ids: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "channel_id=&leaving_team_ids=")
val request = Request.Builder()
  .url("{{baseUrl}}/admin.conversations.disconnectShared")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.conversations.disconnectShared',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({channel_id: '', leaving_team_ids: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.conversations.disconnectShared',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  form: {channel_id: '', leaving_team_ids: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/admin.conversations.disconnectShared');

req.headers({
  token: '',
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  channel_id: '',
  leaving_team_ids: ''
});

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

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

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('channel_id', '');
encodedParams.set('leaving_team_ids', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.conversations.disconnectShared',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('channel_id', '');
encodedParams.set('leaving_team_ids', '');

const url = '{{baseUrl}}/admin.conversations.disconnectShared';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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

#import 

NSDictionary *headers = @{ @"token": @"",
                           @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"channel_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&leaving_team_ids=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin.conversations.disconnectShared"]
                                                       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}}/admin.conversations.disconnectShared" in
let headers = Header.add_list (Header.init ()) [
  ("token", "");
  ("content-type", "application/x-www-form-urlencoded");
] in
let body = Cohttp_lwt_body.of_string "channel_id=&leaving_team_ids=" in

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

 "{{baseUrl}}/admin.conversations.disconnectShared",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "channel_id=&leaving_team_ids=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "token: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/admin.conversations.disconnectShared', [
  'form_params' => [
    'channel_id' => '',
    'leaving_team_ids' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin.conversations.disconnectShared');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'channel_id' => '',
  'leaving_team_ids' => ''
]);

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

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

append(new http\QueryString([
  'channel_id' => '',
  'leaving_team_ids' => ''
]));

$request->setRequestUrl('{{baseUrl}}/admin.conversations.disconnectShared');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.conversations.disconnectShared' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'channel_id=&leaving_team_ids='

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.conversations.disconnectShared' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'channel_id=&leaving_team_ids='

import http.client

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

payload = "channel_id=&leaving_team_ids="

headers = {
    'token': "",
    'content-type': "application/x-www-form-urlencoded"
}

conn.request("POST", "/baseUrl/admin.conversations.disconnectShared", payload, headers)

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

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

import requests

url = "{{baseUrl}}/admin.conversations.disconnectShared"

payload = {
    "channel_id": "",
    "leaving_team_ids": ""
}
headers = {
    "token": "",
    "content-type": "application/x-www-form-urlencoded"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.conversations.disconnectShared"

payload <- "channel_id=&leaving_team_ids="

encode <- "form"

response <- VERB("POST", url, body = payload, add_headers('token' = ''), content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.conversations.disconnectShared")

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

request = Net::HTTP::Post.new(url)
request["token"] = ''
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "channel_id=&leaving_team_ids="

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

require 'faraday'

data = {
  :channel_id => "",
  :leaving_team_ids => "",
}

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

response = conn.post('/baseUrl/admin.conversations.disconnectShared') do |req|
  req.headers['token'] = ''
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.conversations.disconnectShared";

    let payload = json!({
        "channel_id": "",
        "leaving_team_ids": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("token", "".parse().unwrap());
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/admin.conversations.disconnectShared \
  content-type:application/x-www-form-urlencoded \
  token:'' \
  channel_id='' \
  leaving_team_ids=''

wget --quiet \
  --method POST \
  --header 'token: ' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'channel_id=&leaving_team_ids=' \
  --output-document \
  - {{baseUrl}}/admin.conversations.disconnectShared

import Foundation

let headers = [
  "token": "",
  "content-type": "application/x-www-form-urlencoded"
]

let postData = NSMutableData(data: "channel_id=".data(using: String.Encoding.utf8)!)
postData.append("&leaving_team_ids=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.conversations.disconnectShared")! 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}}/admin.conversations.getConversationPrefs?channel_id=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/admin.conversations.getConversationPrefs" {:headers {:token ""}
                                                                                    :query-params {:channel_id ""}})

require "http/client"

url = "{{baseUrl}}/admin.conversations.getConversationPrefs?channel_id="
headers = HTTP::Headers{
  "token" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/admin.conversations.getConversationPrefs?channel_id="),
    Headers =
    {
        { "token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.conversations.getConversationPrefs?channel_id=");
var request = new RestRequest("", Method.Get);
request.AddHeader("token", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin.conversations.getConversationPrefs?channel_id="

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

	req.Header.Add("token", "")

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

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

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

}

GET /baseUrl/admin.conversations.getConversationPrefs?channel_id= HTTP/1.1
Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin.conversations.getConversationPrefs?channel_id=")
  .setHeader("token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.conversations.getConversationPrefs?channel_id="))
    .header("token", "")
    .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}}/admin.conversations.getConversationPrefs?channel_id=")
  .get()
  .addHeader("token", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/admin.conversations.getConversationPrefs?channel_id=")
  .header("token", "")
  .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}}/admin.conversations.getConversationPrefs?channel_id=');
xhr.setRequestHeader('token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin.conversations.getConversationPrefs',
  params: {channel_id: ''},
  headers: {token: ''}
};

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

const url = '{{baseUrl}}/admin.conversations.getConversationPrefs?channel_id=';
const options = {method: 'GET', headers: {token: ''}};

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}}/admin.conversations.getConversationPrefs?channel_id=',
  method: 'GET',
  headers: {
    token: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin.conversations.getConversationPrefs?channel_id=")
  .get()
  .addHeader("token", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.conversations.getConversationPrefs?channel_id=',
  headers: {
    token: ''
  }
};

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}}/admin.conversations.getConversationPrefs',
  qs: {channel_id: ''},
  headers: {token: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/admin.conversations.getConversationPrefs');

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

req.headers({
  token: ''
});

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}}/admin.conversations.getConversationPrefs',
  params: {channel_id: ''},
  headers: {token: ''}
};

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

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

const url = '{{baseUrl}}/admin.conversations.getConversationPrefs?channel_id=';
const options = {method: 'GET', headers: {token: ''}};

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

#import 

NSDictionary *headers = @{ @"token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin.conversations.getConversationPrefs?channel_id="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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}}/admin.conversations.getConversationPrefs?channel_id=" in
let headers = Header.add (Header.init ()) "token" "" in

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

 "{{baseUrl}}/admin.conversations.getConversationPrefs?channel_id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "token: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/admin.conversations.getConversationPrefs?channel_id=', [
  'headers' => [
    'token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin.conversations.getConversationPrefs');
$request->setMethod(HTTP_METH_GET);

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

$request->setHeaders([
  'token' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/admin.conversations.getConversationPrefs');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'channel_id' => ''
]));

$request->setHeaders([
  'token' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.conversations.getConversationPrefs?channel_id=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.conversations.getConversationPrefs?channel_id=' -Method GET -Headers $headers

import http.client

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

headers = { 'token': "" }

conn.request("GET", "/baseUrl/admin.conversations.getConversationPrefs?channel_id=", headers=headers)

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

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

import requests

url = "{{baseUrl}}/admin.conversations.getConversationPrefs"

querystring = {"channel_id":""}

headers = {"token": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.conversations.getConversationPrefs"

queryString <- list(channel_id = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.conversations.getConversationPrefs?channel_id=")

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

request = Net::HTTP::Get.new(url)
request["token"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/admin.conversations.getConversationPrefs') do |req|
  req.headers['token'] = ''
  req.params['channel_id'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.conversations.getConversationPrefs";

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("token", "".parse().unwrap());

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

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

    dbg!(results);
}

http GET '{{baseUrl}}/admin.conversations.getConversationPrefs?channel_id=' \
  token:''

wget --quiet \
  --method GET \
  --header 'token: ' \
  --output-document \
  - '{{baseUrl}}/admin.conversations.getConversationPrefs?channel_id='

import Foundation

let headers = ["token": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.conversations.getConversationPrefs?channel_id=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin.conversations.getTeams?channel_id=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/admin.conversations.getTeams" {:headers {:token ""}
                                                                        :query-params {:channel_id ""}})

require "http/client"

url = "{{baseUrl}}/admin.conversations.getTeams?channel_id="
headers = HTTP::Headers{
  "token" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/admin.conversations.getTeams?channel_id="),
    Headers =
    {
        { "token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.conversations.getTeams?channel_id=");
var request = new RestRequest("", Method.Get);
request.AddHeader("token", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin.conversations.getTeams?channel_id="

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

	req.Header.Add("token", "")

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

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

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

}

GET /baseUrl/admin.conversations.getTeams?channel_id= HTTP/1.1
Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin.conversations.getTeams?channel_id=")
  .setHeader("token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.conversations.getTeams?channel_id="))
    .header("token", "")
    .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}}/admin.conversations.getTeams?channel_id=")
  .get()
  .addHeader("token", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/admin.conversations.getTeams?channel_id=")
  .header("token", "")
  .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}}/admin.conversations.getTeams?channel_id=');
xhr.setRequestHeader('token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin.conversations.getTeams',
  params: {channel_id: ''},
  headers: {token: ''}
};

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

const url = '{{baseUrl}}/admin.conversations.getTeams?channel_id=';
const options = {method: 'GET', headers: {token: ''}};

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}}/admin.conversations.getTeams?channel_id=',
  method: 'GET',
  headers: {
    token: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin.conversations.getTeams?channel_id=")
  .get()
  .addHeader("token", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.conversations.getTeams?channel_id=',
  headers: {
    token: ''
  }
};

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}}/admin.conversations.getTeams',
  qs: {channel_id: ''},
  headers: {token: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/admin.conversations.getTeams');

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

req.headers({
  token: ''
});

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}}/admin.conversations.getTeams',
  params: {channel_id: ''},
  headers: {token: ''}
};

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

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

const url = '{{baseUrl}}/admin.conversations.getTeams?channel_id=';
const options = {method: 'GET', headers: {token: ''}};

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

#import 

NSDictionary *headers = @{ @"token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin.conversations.getTeams?channel_id="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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}}/admin.conversations.getTeams?channel_id=" in
let headers = Header.add (Header.init ()) "token" "" in

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

 "{{baseUrl}}/admin.conversations.getTeams?channel_id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "token: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/admin.conversations.getTeams?channel_id=', [
  'headers' => [
    'token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin.conversations.getTeams');
$request->setMethod(HTTP_METH_GET);

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

$request->setHeaders([
  'token' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/admin.conversations.getTeams');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'channel_id' => ''
]));

$request->setHeaders([
  'token' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.conversations.getTeams?channel_id=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.conversations.getTeams?channel_id=' -Method GET -Headers $headers

import http.client

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

headers = { 'token': "" }

conn.request("GET", "/baseUrl/admin.conversations.getTeams?channel_id=", headers=headers)

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

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

import requests

url = "{{baseUrl}}/admin.conversations.getTeams"

querystring = {"channel_id":""}

headers = {"token": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.conversations.getTeams"

queryString <- list(channel_id = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.conversations.getTeams?channel_id=")

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

request = Net::HTTP::Get.new(url)
request["token"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/admin.conversations.getTeams') do |req|
  req.headers['token'] = ''
  req.params['channel_id'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.conversations.getTeams";

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("token", "".parse().unwrap());

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

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

    dbg!(results);
}

http GET '{{baseUrl}}/admin.conversations.getTeams?channel_id=' \
  token:''

wget --quiet \
  --method GET \
  --header 'token: ' \
  --output-document \
  - '{{baseUrl}}/admin.conversations.getTeams?channel_id='

import Foundation

let headers = ["token": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.conversations.getTeams?channel_id=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin.conversations.invite");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "token: ");
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "channel_id=&user_ids=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/admin.conversations.invite" {:headers {:token ""}
                                                                       :form-params {:channel_id ""
                                                                                     :user_ids ""}})

require "http/client"

url = "{{baseUrl}}/admin.conversations.invite"
headers = HTTP::Headers{
  "token" => ""
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "channel_id=&user_ids="

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}}/admin.conversations.invite"),
    Headers =
    {
        { "token", "" },
    },
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "channel_id", "" },
        { "user_ids", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.conversations.invite");
var request = new RestRequest("", Method.Post);
request.AddHeader("token", "");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "channel_id=&user_ids=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin.conversations.invite"

	payload := strings.NewReader("channel_id=&user_ids=")

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

	req.Header.Add("token", "")
	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}

POST /baseUrl/admin.conversations.invite HTTP/1.1
Token: 
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 21

channel_id=&user_ids=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin.conversations.invite")
  .setHeader("token", "")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("channel_id=&user_ids=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.conversations.invite"))
    .header("token", "")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("channel_id=&user_ids="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "channel_id=&user_ids=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin.conversations.invite")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin.conversations.invite")
  .header("token", "")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("channel_id=&user_ids=")
  .asString();

const data = 'channel_id=&user_ids=';

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

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

xhr.open('POST', '{{baseUrl}}/admin.conversations.invite');
xhr.setRequestHeader('token', '');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('channel_id', '');
encodedParams.set('user_ids', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.conversations.invite',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/admin.conversations.invite';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({channel_id: '', user_ids: ''})
};

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}}/admin.conversations.invite',
  method: 'POST',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    channel_id: '',
    user_ids: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "channel_id=&user_ids=")
val request = Request.Builder()
  .url("{{baseUrl}}/admin.conversations.invite")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.conversations.invite',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({channel_id: '', user_ids: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.conversations.invite',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  form: {channel_id: '', user_ids: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/admin.conversations.invite');

req.headers({
  token: '',
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  channel_id: '',
  user_ids: ''
});

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

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

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('channel_id', '');
encodedParams.set('user_ids', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.conversations.invite',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('channel_id', '');
encodedParams.set('user_ids', '');

const url = '{{baseUrl}}/admin.conversations.invite';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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

#import 

NSDictionary *headers = @{ @"token": @"",
                           @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"channel_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&user_ids=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin.conversations.invite"]
                                                       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}}/admin.conversations.invite" in
let headers = Header.add_list (Header.init ()) [
  ("token", "");
  ("content-type", "application/x-www-form-urlencoded");
] in
let body = Cohttp_lwt_body.of_string "channel_id=&user_ids=" in

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

 "{{baseUrl}}/admin.conversations.invite",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "channel_id=&user_ids=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "token: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/admin.conversations.invite', [
  'form_params' => [
    'channel_id' => '',
    'user_ids' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin.conversations.invite');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'channel_id' => '',
  'user_ids' => ''
]);

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

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

append(new http\QueryString([
  'channel_id' => '',
  'user_ids' => ''
]));

$request->setRequestUrl('{{baseUrl}}/admin.conversations.invite');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.conversations.invite' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'channel_id=&user_ids='

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.conversations.invite' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'channel_id=&user_ids='

import http.client

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

payload = "channel_id=&user_ids="

headers = {
    'token': "",
    'content-type': "application/x-www-form-urlencoded"
}

conn.request("POST", "/baseUrl/admin.conversations.invite", payload, headers)

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

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

import requests

url = "{{baseUrl}}/admin.conversations.invite"

payload = {
    "channel_id": "",
    "user_ids": ""
}
headers = {
    "token": "",
    "content-type": "application/x-www-form-urlencoded"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.conversations.invite"

payload <- "channel_id=&user_ids="

encode <- "form"

response <- VERB("POST", url, body = payload, add_headers('token' = ''), content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.conversations.invite")

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

request = Net::HTTP::Post.new(url)
request["token"] = ''
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "channel_id=&user_ids="

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

require 'faraday'

data = {
  :channel_id => "",
  :user_ids => "",
}

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

response = conn.post('/baseUrl/admin.conversations.invite') do |req|
  req.headers['token'] = ''
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.conversations.invite";

    let payload = json!({
        "channel_id": "",
        "user_ids": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("token", "".parse().unwrap());
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/admin.conversations.invite \
  content-type:application/x-www-form-urlencoded \
  token:'' \
  channel_id='' \
  user_ids=''

wget --quiet \
  --method POST \
  --header 'token: ' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'channel_id=&user_ids=' \
  --output-document \
  - {{baseUrl}}/admin.conversations.invite

import Foundation

let headers = [
  "token": "",
  "content-type": "application/x-www-form-urlencoded"
]

let postData = NSMutableData(data: "channel_id=".data(using: String.Encoding.utf8)!)
postData.append("&user_ids=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.conversations.invite")! 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}}/admin.conversations.rename");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "token: ");
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "channel_id=&name=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/admin.conversations.rename" {:headers {:token ""}
                                                                       :form-params {:channel_id ""
                                                                                     :name ""}})

require "http/client"

url = "{{baseUrl}}/admin.conversations.rename"
headers = HTTP::Headers{
  "token" => ""
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "channel_id=&name="

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}}/admin.conversations.rename"),
    Headers =
    {
        { "token", "" },
    },
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "channel_id", "" },
        { "name", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.conversations.rename");
var request = new RestRequest("", Method.Post);
request.AddHeader("token", "");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "channel_id=&name=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin.conversations.rename"

	payload := strings.NewReader("channel_id=&name=")

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

	req.Header.Add("token", "")
	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}

POST /baseUrl/admin.conversations.rename HTTP/1.1
Token: 
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 17

channel_id=&name=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin.conversations.rename")
  .setHeader("token", "")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("channel_id=&name=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.conversations.rename"))
    .header("token", "")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("channel_id=&name="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "channel_id=&name=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin.conversations.rename")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin.conversations.rename")
  .header("token", "")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("channel_id=&name=")
  .asString();

const data = 'channel_id=&name=';

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

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

xhr.open('POST', '{{baseUrl}}/admin.conversations.rename');
xhr.setRequestHeader('token', '');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('channel_id', '');
encodedParams.set('name', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.conversations.rename',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/admin.conversations.rename';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({channel_id: '', name: ''})
};

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}}/admin.conversations.rename',
  method: 'POST',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    channel_id: '',
    name: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "channel_id=&name=")
val request = Request.Builder()
  .url("{{baseUrl}}/admin.conversations.rename")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.conversations.rename',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({channel_id: '', name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.conversations.rename',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  form: {channel_id: '', name: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/admin.conversations.rename');

req.headers({
  token: '',
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  channel_id: '',
  name: ''
});

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

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

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('channel_id', '');
encodedParams.set('name', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.conversations.rename',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('channel_id', '');
encodedParams.set('name', '');

const url = '{{baseUrl}}/admin.conversations.rename';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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

#import 

NSDictionary *headers = @{ @"token": @"",
                           @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"channel_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&name=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin.conversations.rename"]
                                                       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}}/admin.conversations.rename" in
let headers = Header.add_list (Header.init ()) [
  ("token", "");
  ("content-type", "application/x-www-form-urlencoded");
] in
let body = Cohttp_lwt_body.of_string "channel_id=&name=" in

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

 "{{baseUrl}}/admin.conversations.rename",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "channel_id=&name=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "token: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/admin.conversations.rename', [
  'form_params' => [
    'channel_id' => '',
    'name' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin.conversations.rename');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'channel_id' => '',
  'name' => ''
]);

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

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

append(new http\QueryString([
  'channel_id' => '',
  'name' => ''
]));

$request->setRequestUrl('{{baseUrl}}/admin.conversations.rename');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.conversations.rename' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'channel_id=&name='

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.conversations.rename' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'channel_id=&name='

import http.client

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

payload = "channel_id=&name="

headers = {
    'token': "",
    'content-type': "application/x-www-form-urlencoded"
}

conn.request("POST", "/baseUrl/admin.conversations.rename", payload, headers)

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

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

import requests

url = "{{baseUrl}}/admin.conversations.rename"

payload = {
    "channel_id": "",
    "name": ""
}
headers = {
    "token": "",
    "content-type": "application/x-www-form-urlencoded"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.conversations.rename"

payload <- "channel_id=&name="

encode <- "form"

response <- VERB("POST", url, body = payload, add_headers('token' = ''), content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.conversations.rename")

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

request = Net::HTTP::Post.new(url)
request["token"] = ''
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "channel_id=&name="

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

require 'faraday'

data = {
  :channel_id => "",
  :name => "",
}

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

response = conn.post('/baseUrl/admin.conversations.rename') do |req|
  req.headers['token'] = ''
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.conversations.rename";

    let payload = json!({
        "channel_id": "",
        "name": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("token", "".parse().unwrap());
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/admin.conversations.rename \
  content-type:application/x-www-form-urlencoded \
  token:'' \
  channel_id='' \
  name=''

wget --quiet \
  --method POST \
  --header 'token: ' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'channel_id=&name=' \
  --output-document \
  - {{baseUrl}}/admin.conversations.rename

import Foundation

let headers = [
  "token": "",
  "content-type": "application/x-www-form-urlencoded"
]

let postData = NSMutableData(data: "channel_id=".data(using: String.Encoding.utf8)!)
postData.append("&name=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.conversations.rename")! 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}}/admin.conversations.search");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/admin.conversations.search" {:headers {:token ""}})

require "http/client"

url = "{{baseUrl}}/admin.conversations.search"
headers = HTTP::Headers{
  "token" => ""
}

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

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

var client = new RestClient("{{baseUrl}}/admin.conversations.search");
var request = new RestRequest("", Method.Get);
request.AddHeader("token", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin.conversations.search"

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

	req.Header.Add("token", "")

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

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

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

}

GET /baseUrl/admin.conversations.search HTTP/1.1
Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin.conversations.search")
  .setHeader("token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.conversations.search"))
    .header("token", "")
    .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}}/admin.conversations.search")
  .get()
  .addHeader("token", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/admin.conversations.search")
  .header("token", "")
  .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}}/admin.conversations.search');
xhr.setRequestHeader('token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin.conversations.search',
  headers: {token: ''}
};

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

const url = '{{baseUrl}}/admin.conversations.search';
const options = {method: 'GET', headers: {token: ''}};

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}}/admin.conversations.search',
  method: 'GET',
  headers: {
    token: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin.conversations.search")
  .get()
  .addHeader("token", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.conversations.search',
  headers: {
    token: ''
  }
};

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}}/admin.conversations.search',
  headers: {token: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/admin.conversations.search');

req.headers({
  token: ''
});

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}}/admin.conversations.search',
  headers: {token: ''}
};

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

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

const url = '{{baseUrl}}/admin.conversations.search';
const options = {method: 'GET', headers: {token: ''}};

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

#import 

NSDictionary *headers = @{ @"token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin.conversations.search"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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}}/admin.conversations.search" in
let headers = Header.add (Header.init ()) "token" "" in

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

 "{{baseUrl}}/admin.conversations.search",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "token: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/admin.conversations.search', [
  'headers' => [
    'token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin.conversations.search');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'token' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/admin.conversations.search');
$request->setRequestMethod('GET');
$request->setHeaders([
  'token' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.conversations.search' -Method GET -Headers $headers

$headers=@{}
$headers.Add("token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.conversations.search' -Method GET -Headers $headers

import http.client

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

headers = { 'token': "" }

conn.request("GET", "/baseUrl/admin.conversations.search", headers=headers)

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

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

import requests

url = "{{baseUrl}}/admin.conversations.search"

headers = {"token": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.conversations.search"

response <- VERB("GET", url, add_headers('token' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.conversations.search")

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

request = Net::HTTP::Get.new(url)
request["token"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/admin.conversations.search') do |req|
  req.headers['token'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.conversations.search";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("token", "".parse().unwrap());

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

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

    dbg!(results);
}

http GET {{baseUrl}}/admin.conversations.search \
  token:''

wget --quiet \
  --method GET \
  --header 'token: ' \
  --output-document \
  - {{baseUrl}}/admin.conversations.search

import Foundation

let headers = ["token": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.conversations.search")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin.conversations.setConversationPrefs");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "token: ");
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "channel_id=&prefs=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/admin.conversations.setConversationPrefs" {:headers {:token ""}
                                                                                     :form-params {:channel_id ""
                                                                                                   :prefs ""}})

require "http/client"

url = "{{baseUrl}}/admin.conversations.setConversationPrefs"
headers = HTTP::Headers{
  "token" => ""
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "channel_id=&prefs="

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}}/admin.conversations.setConversationPrefs"),
    Headers =
    {
        { "token", "" },
    },
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "channel_id", "" },
        { "prefs", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.conversations.setConversationPrefs");
var request = new RestRequest("", Method.Post);
request.AddHeader("token", "");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "channel_id=&prefs=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin.conversations.setConversationPrefs"

	payload := strings.NewReader("channel_id=&prefs=")

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

	req.Header.Add("token", "")
	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}

POST /baseUrl/admin.conversations.setConversationPrefs HTTP/1.1
Token: 
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 18

channel_id=&prefs=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin.conversations.setConversationPrefs")
  .setHeader("token", "")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("channel_id=&prefs=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.conversations.setConversationPrefs"))
    .header("token", "")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("channel_id=&prefs="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "channel_id=&prefs=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin.conversations.setConversationPrefs")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin.conversations.setConversationPrefs")
  .header("token", "")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("channel_id=&prefs=")
  .asString();

const data = 'channel_id=&prefs=';

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

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

xhr.open('POST', '{{baseUrl}}/admin.conversations.setConversationPrefs');
xhr.setRequestHeader('token', '');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('channel_id', '');
encodedParams.set('prefs', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.conversations.setConversationPrefs',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/admin.conversations.setConversationPrefs';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({channel_id: '', prefs: ''})
};

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}}/admin.conversations.setConversationPrefs',
  method: 'POST',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    channel_id: '',
    prefs: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "channel_id=&prefs=")
val request = Request.Builder()
  .url("{{baseUrl}}/admin.conversations.setConversationPrefs")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.conversations.setConversationPrefs',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({channel_id: '', prefs: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.conversations.setConversationPrefs',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  form: {channel_id: '', prefs: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/admin.conversations.setConversationPrefs');

req.headers({
  token: '',
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  channel_id: '',
  prefs: ''
});

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

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

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('channel_id', '');
encodedParams.set('prefs', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.conversations.setConversationPrefs',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('channel_id', '');
encodedParams.set('prefs', '');

const url = '{{baseUrl}}/admin.conversations.setConversationPrefs';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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

#import 

NSDictionary *headers = @{ @"token": @"",
                           @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"channel_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&prefs=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin.conversations.setConversationPrefs"]
                                                       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}}/admin.conversations.setConversationPrefs" in
let headers = Header.add_list (Header.init ()) [
  ("token", "");
  ("content-type", "application/x-www-form-urlencoded");
] in
let body = Cohttp_lwt_body.of_string "channel_id=&prefs=" in

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

 "{{baseUrl}}/admin.conversations.setConversationPrefs",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "channel_id=&prefs=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "token: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/admin.conversations.setConversationPrefs', [
  'form_params' => [
    'channel_id' => '',
    'prefs' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin.conversations.setConversationPrefs');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'channel_id' => '',
  'prefs' => ''
]);

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

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

append(new http\QueryString([
  'channel_id' => '',
  'prefs' => ''
]));

$request->setRequestUrl('{{baseUrl}}/admin.conversations.setConversationPrefs');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.conversations.setConversationPrefs' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'channel_id=&prefs='

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.conversations.setConversationPrefs' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'channel_id=&prefs='

import http.client

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

payload = "channel_id=&prefs="

headers = {
    'token': "",
    'content-type': "application/x-www-form-urlencoded"
}

conn.request("POST", "/baseUrl/admin.conversations.setConversationPrefs", payload, headers)

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

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

import requests

url = "{{baseUrl}}/admin.conversations.setConversationPrefs"

payload = {
    "channel_id": "",
    "prefs": ""
}
headers = {
    "token": "",
    "content-type": "application/x-www-form-urlencoded"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.conversations.setConversationPrefs"

payload <- "channel_id=&prefs="

encode <- "form"

response <- VERB("POST", url, body = payload, add_headers('token' = ''), content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.conversations.setConversationPrefs")

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

request = Net::HTTP::Post.new(url)
request["token"] = ''
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "channel_id=&prefs="

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

require 'faraday'

data = {
  :channel_id => "",
  :prefs => "",
}

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

response = conn.post('/baseUrl/admin.conversations.setConversationPrefs') do |req|
  req.headers['token'] = ''
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.conversations.setConversationPrefs";

    let payload = json!({
        "channel_id": "",
        "prefs": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("token", "".parse().unwrap());
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/admin.conversations.setConversationPrefs \
  content-type:application/x-www-form-urlencoded \
  token:'' \
  channel_id='' \
  prefs=''

wget --quiet \
  --method POST \
  --header 'token: ' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'channel_id=&prefs=' \
  --output-document \
  - {{baseUrl}}/admin.conversations.setConversationPrefs

import Foundation

let headers = [
  "token": "",
  "content-type": "application/x-www-form-urlencoded"
]

let postData = NSMutableData(data: "channel_id=".data(using: String.Encoding.utf8)!)
postData.append("&prefs=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.conversations.setConversationPrefs")! 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}}/admin.conversations.setTeams");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "token: ");
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "channel_id=&org_channel=&target_team_ids=&team_id=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/admin.conversations.setTeams" {:headers {:token ""}
                                                                         :form-params {:channel_id ""
                                                                                       :org_channel ""
                                                                                       :target_team_ids ""
                                                                                       :team_id ""}})

require "http/client"

url = "{{baseUrl}}/admin.conversations.setTeams"
headers = HTTP::Headers{
  "token" => ""
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "channel_id=&org_channel=&target_team_ids=&team_id="

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}}/admin.conversations.setTeams"),
    Headers =
    {
        { "token", "" },
    },
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "channel_id", "" },
        { "org_channel", "" },
        { "target_team_ids", "" },
        { "team_id", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.conversations.setTeams");
var request = new RestRequest("", Method.Post);
request.AddHeader("token", "");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "channel_id=&org_channel=&target_team_ids=&team_id=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin.conversations.setTeams"

	payload := strings.NewReader("channel_id=&org_channel=&target_team_ids=&team_id=")

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

	req.Header.Add("token", "")
	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}

POST /baseUrl/admin.conversations.setTeams HTTP/1.1
Token: 
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 50

channel_id=&org_channel=&target_team_ids=&team_id=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin.conversations.setTeams")
  .setHeader("token", "")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("channel_id=&org_channel=&target_team_ids=&team_id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.conversations.setTeams"))
    .header("token", "")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("channel_id=&org_channel=&target_team_ids=&team_id="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "channel_id=&org_channel=&target_team_ids=&team_id=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin.conversations.setTeams")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin.conversations.setTeams")
  .header("token", "")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("channel_id=&org_channel=&target_team_ids=&team_id=")
  .asString();

const data = 'channel_id=&org_channel=&target_team_ids=&team_id=';

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

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

xhr.open('POST', '{{baseUrl}}/admin.conversations.setTeams');
xhr.setRequestHeader('token', '');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('channel_id', '');
encodedParams.set('org_channel', '');
encodedParams.set('target_team_ids', '');
encodedParams.set('team_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.conversations.setTeams',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/admin.conversations.setTeams';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({channel_id: '', org_channel: '', target_team_ids: '', team_id: ''})
};

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}}/admin.conversations.setTeams',
  method: 'POST',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    channel_id: '',
    org_channel: '',
    target_team_ids: '',
    team_id: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "channel_id=&org_channel=&target_team_ids=&team_id=")
val request = Request.Builder()
  .url("{{baseUrl}}/admin.conversations.setTeams")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.conversations.setTeams',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({channel_id: '', org_channel: '', target_team_ids: '', team_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.conversations.setTeams',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  form: {channel_id: '', org_channel: '', target_team_ids: '', team_id: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/admin.conversations.setTeams');

req.headers({
  token: '',
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  channel_id: '',
  org_channel: '',
  target_team_ids: '',
  team_id: ''
});

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

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

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('channel_id', '');
encodedParams.set('org_channel', '');
encodedParams.set('target_team_ids', '');
encodedParams.set('team_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.conversations.setTeams',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('channel_id', '');
encodedParams.set('org_channel', '');
encodedParams.set('target_team_ids', '');
encodedParams.set('team_id', '');

const url = '{{baseUrl}}/admin.conversations.setTeams';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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

#import 

NSDictionary *headers = @{ @"token": @"",
                           @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"channel_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&org_channel=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&target_team_ids=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&team_id=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin.conversations.setTeams"]
                                                       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}}/admin.conversations.setTeams" in
let headers = Header.add_list (Header.init ()) [
  ("token", "");
  ("content-type", "application/x-www-form-urlencoded");
] in
let body = Cohttp_lwt_body.of_string "channel_id=&org_channel=&target_team_ids=&team_id=" in

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

 "{{baseUrl}}/admin.conversations.setTeams",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "channel_id=&org_channel=&target_team_ids=&team_id=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "token: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/admin.conversations.setTeams', [
  'form_params' => [
    'channel_id' => '',
    'org_channel' => '',
    'target_team_ids' => '',
    'team_id' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin.conversations.setTeams');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'channel_id' => '',
  'org_channel' => '',
  'target_team_ids' => '',
  'team_id' => ''
]);

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

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

append(new http\QueryString([
  'channel_id' => '',
  'org_channel' => '',
  'target_team_ids' => '',
  'team_id' => ''
]));

$request->setRequestUrl('{{baseUrl}}/admin.conversations.setTeams');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.conversations.setTeams' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'channel_id=&org_channel=&target_team_ids=&team_id='

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.conversations.setTeams' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'channel_id=&org_channel=&target_team_ids=&team_id='

import http.client

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

payload = "channel_id=&org_channel=&target_team_ids=&team_id="

headers = {
    'token': "",
    'content-type': "application/x-www-form-urlencoded"
}

conn.request("POST", "/baseUrl/admin.conversations.setTeams", payload, headers)

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

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

import requests

url = "{{baseUrl}}/admin.conversations.setTeams"

payload = {
    "channel_id": "",
    "org_channel": "",
    "target_team_ids": "",
    "team_id": ""
}
headers = {
    "token": "",
    "content-type": "application/x-www-form-urlencoded"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.conversations.setTeams"

payload <- "channel_id=&org_channel=&target_team_ids=&team_id="

encode <- "form"

response <- VERB("POST", url, body = payload, add_headers('token' = ''), content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.conversations.setTeams")

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

request = Net::HTTP::Post.new(url)
request["token"] = ''
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "channel_id=&org_channel=&target_team_ids=&team_id="

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

require 'faraday'

data = {
  :channel_id => "",
  :org_channel => "",
  :target_team_ids => "",
  :team_id => "",
}

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

response = conn.post('/baseUrl/admin.conversations.setTeams') do |req|
  req.headers['token'] = ''
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.conversations.setTeams";

    let payload = json!({
        "channel_id": "",
        "org_channel": "",
        "target_team_ids": "",
        "team_id": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("token", "".parse().unwrap());
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/admin.conversations.setTeams \
  content-type:application/x-www-form-urlencoded \
  token:'' \
  channel_id='' \
  org_channel='' \
  target_team_ids='' \
  team_id=''

wget --quiet \
  --method POST \
  --header 'token: ' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'channel_id=&org_channel=&target_team_ids=&team_id=' \
  --output-document \
  - {{baseUrl}}/admin.conversations.setTeams

import Foundation

let headers = [
  "token": "",
  "content-type": "application/x-www-form-urlencoded"
]

let postData = NSMutableData(data: "channel_id=".data(using: String.Encoding.utf8)!)
postData.append("&org_channel=".data(using: String.Encoding.utf8)!)
postData.append("&target_team_ids=".data(using: String.Encoding.utf8)!)
postData.append("&team_id=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.conversations.setTeams")! 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}}/admin.conversations.unarchive");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "token: ");
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "channel_id=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/admin.conversations.unarchive" {:headers {:token ""}
                                                                          :form-params {:channel_id ""}})

require "http/client"

url = "{{baseUrl}}/admin.conversations.unarchive"
headers = HTTP::Headers{
  "token" => ""
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "channel_id="

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}}/admin.conversations.unarchive"),
    Headers =
    {
        { "token", "" },
    },
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "channel_id", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.conversations.unarchive");
var request = new RestRequest("", Method.Post);
request.AddHeader("token", "");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "channel_id=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin.conversations.unarchive"

	payload := strings.NewReader("channel_id=")

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

	req.Header.Add("token", "")
	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}

POST /baseUrl/admin.conversations.unarchive HTTP/1.1
Token: 
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 11

channel_id=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin.conversations.unarchive")
  .setHeader("token", "")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("channel_id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.conversations.unarchive"))
    .header("token", "")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("channel_id="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "channel_id=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin.conversations.unarchive")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin.conversations.unarchive")
  .header("token", "")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("channel_id=")
  .asString();

const data = 'channel_id=';

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

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

xhr.open('POST', '{{baseUrl}}/admin.conversations.unarchive');
xhr.setRequestHeader('token', '');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('channel_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.conversations.unarchive',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/admin.conversations.unarchive';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({channel_id: ''})
};

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}}/admin.conversations.unarchive',
  method: 'POST',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    channel_id: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "channel_id=")
val request = Request.Builder()
  .url("{{baseUrl}}/admin.conversations.unarchive")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.conversations.unarchive',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({channel_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.conversations.unarchive',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  form: {channel_id: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/admin.conversations.unarchive');

req.headers({
  token: '',
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  channel_id: ''
});

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

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

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('channel_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.conversations.unarchive',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('channel_id', '');

const url = '{{baseUrl}}/admin.conversations.unarchive';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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

#import 

NSDictionary *headers = @{ @"token": @"",
                           @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"channel_id=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin.conversations.unarchive"]
                                                       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}}/admin.conversations.unarchive" in
let headers = Header.add_list (Header.init ()) [
  ("token", "");
  ("content-type", "application/x-www-form-urlencoded");
] in
let body = Cohttp_lwt_body.of_string "channel_id=" in

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

 "{{baseUrl}}/admin.conversations.unarchive",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "channel_id=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "token: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/admin.conversations.unarchive', [
  'form_params' => [
    'channel_id' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin.conversations.unarchive');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'channel_id' => ''
]);

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

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

append(new http\QueryString([
  'channel_id' => ''
]));

$request->setRequestUrl('{{baseUrl}}/admin.conversations.unarchive');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.conversations.unarchive' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'channel_id='

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.conversations.unarchive' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'channel_id='

import http.client

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

payload = "channel_id="

headers = {
    'token': "",
    'content-type': "application/x-www-form-urlencoded"
}

conn.request("POST", "/baseUrl/admin.conversations.unarchive", payload, headers)

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

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

import requests

url = "{{baseUrl}}/admin.conversations.unarchive"

payload = { "channel_id": "" }
headers = {
    "token": "",
    "content-type": "application/x-www-form-urlencoded"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.conversations.unarchive"

payload <- "channel_id="

encode <- "form"

response <- VERB("POST", url, body = payload, add_headers('token' = ''), content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.conversations.unarchive")

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

request = Net::HTTP::Post.new(url)
request["token"] = ''
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "channel_id="

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

require 'faraday'

data = {
  :channel_id => "",
}

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

response = conn.post('/baseUrl/admin.conversations.unarchive') do |req|
  req.headers['token'] = ''
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.conversations.unarchive";

    let payload = json!({"channel_id": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("token", "".parse().unwrap());
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/admin.conversations.unarchive \
  content-type:application/x-www-form-urlencoded \
  token:'' \
  channel_id=''

wget --quiet \
  --method POST \
  --header 'token: ' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data channel_id= \
  --output-document \
  - {{baseUrl}}/admin.conversations.unarchive

import Foundation

let headers = [
  "token": "",
  "content-type": "application/x-www-form-urlencoded"
]

let postData = NSMutableData(data: "channel_id=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.conversations.unarchive")! 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}}/admin.conversations.ekm.listOriginalConnectedChannelInfo?token=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/admin.conversations.ekm.listOriginalConnectedChannelInfo" {:query-params {:token ""}})

require "http/client"

url = "{{baseUrl}}/admin.conversations.ekm.listOriginalConnectedChannelInfo?token="

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}}/admin.conversations.ekm.listOriginalConnectedChannelInfo?token="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.conversations.ekm.listOriginalConnectedChannelInfo?token=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin.conversations.ekm.listOriginalConnectedChannelInfo?token="

	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/admin.conversations.ekm.listOriginalConnectedChannelInfo?token= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin.conversations.ekm.listOriginalConnectedChannelInfo?token=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.conversations.ekm.listOriginalConnectedChannelInfo?token="))
    .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}}/admin.conversations.ekm.listOriginalConnectedChannelInfo?token=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/admin.conversations.ekm.listOriginalConnectedChannelInfo?token=")
  .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}}/admin.conversations.ekm.listOriginalConnectedChannelInfo?token=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin.conversations.ekm.listOriginalConnectedChannelInfo',
  params: {token: ''}
};

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

const url = '{{baseUrl}}/admin.conversations.ekm.listOriginalConnectedChannelInfo?token=';
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}}/admin.conversations.ekm.listOriginalConnectedChannelInfo?token=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin.conversations.ekm.listOriginalConnectedChannelInfo?token=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.conversations.ekm.listOriginalConnectedChannelInfo?token=',
  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}}/admin.conversations.ekm.listOriginalConnectedChannelInfo',
  qs: {token: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/admin.conversations.ekm.listOriginalConnectedChannelInfo');

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

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}}/admin.conversations.ekm.listOriginalConnectedChannelInfo',
  params: {token: ''}
};

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

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

const url = '{{baseUrl}}/admin.conversations.ekm.listOriginalConnectedChannelInfo?token=';
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}}/admin.conversations.ekm.listOriginalConnectedChannelInfo?token="]
                                                       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}}/admin.conversations.ekm.listOriginalConnectedChannelInfo?token=" in

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

 "{{baseUrl}}/admin.conversations.ekm.listOriginalConnectedChannelInfo?token=",
  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}}/admin.conversations.ekm.listOriginalConnectedChannelInfo?token=');

echo $response->getBody();

setUrl('{{baseUrl}}/admin.conversations.ekm.listOriginalConnectedChannelInfo');
$request->setMethod(HTTP_METH_GET);

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

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

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

setRequestUrl('{{baseUrl}}/admin.conversations.ekm.listOriginalConnectedChannelInfo');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'token' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.conversations.ekm.listOriginalConnectedChannelInfo?token=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.conversations.ekm.listOriginalConnectedChannelInfo?token=' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/admin.conversations.ekm.listOriginalConnectedChannelInfo?token=")

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

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

import requests

url = "{{baseUrl}}/admin.conversations.ekm.listOriginalConnectedChannelInfo"

querystring = {"token":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.conversations.ekm.listOriginalConnectedChannelInfo"

queryString <- list(token = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.conversations.ekm.listOriginalConnectedChannelInfo?token=")

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/admin.conversations.ekm.listOriginalConnectedChannelInfo') do |req|
  req.params['token'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.conversations.ekm.listOriginalConnectedChannelInfo";

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

    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}}/admin.conversations.ekm.listOriginalConnectedChannelInfo?token='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/admin.conversations.ekm.listOriginalConnectedChannelInfo?token='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.conversations.ekm.listOriginalConnectedChannelInfo?token=")! 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}}/admin.conversations.restrictAccess.addGroup");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "channel_id=&group_id=&team_id=&token=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/admin.conversations.restrictAccess.addGroup" {:form-params {:channel_id ""
                                                                                                      :group_id ""
                                                                                                      :team_id ""
                                                                                                      :token ""}})

require "http/client"

url = "{{baseUrl}}/admin.conversations.restrictAccess.addGroup"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "channel_id=&group_id=&team_id=&token="

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}}/admin.conversations.restrictAccess.addGroup"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "channel_id", "" },
        { "group_id", "" },
        { "team_id", "" },
        { "token", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.conversations.restrictAccess.addGroup");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "channel_id=&group_id=&team_id=&token=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin.conversations.restrictAccess.addGroup"

	payload := strings.NewReader("channel_id=&group_id=&team_id=&token=")

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}

POST /baseUrl/admin.conversations.restrictAccess.addGroup HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 37

channel_id=&group_id=&team_id=&token=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin.conversations.restrictAccess.addGroup")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("channel_id=&group_id=&team_id=&token=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.conversations.restrictAccess.addGroup"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("channel_id=&group_id=&team_id=&token="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "channel_id=&group_id=&team_id=&token=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin.conversations.restrictAccess.addGroup")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin.conversations.restrictAccess.addGroup")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("channel_id=&group_id=&team_id=&token=")
  .asString();

const data = 'channel_id=&group_id=&team_id=&token=';

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

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

xhr.open('POST', '{{baseUrl}}/admin.conversations.restrictAccess.addGroup');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('channel_id', '');
encodedParams.set('group_id', '');
encodedParams.set('team_id', '');
encodedParams.set('token', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.conversations.restrictAccess.addGroup',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/admin.conversations.restrictAccess.addGroup';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({channel_id: '', group_id: '', team_id: '', token: ''})
};

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}}/admin.conversations.restrictAccess.addGroup',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    channel_id: '',
    group_id: '',
    team_id: '',
    token: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "channel_id=&group_id=&team_id=&token=")
val request = Request.Builder()
  .url("{{baseUrl}}/admin.conversations.restrictAccess.addGroup")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.conversations.restrictAccess.addGroup',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({channel_id: '', group_id: '', team_id: '', token: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.conversations.restrictAccess.addGroup',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {channel_id: '', group_id: '', team_id: '', token: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/admin.conversations.restrictAccess.addGroup');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  channel_id: '',
  group_id: '',
  team_id: '',
  token: ''
});

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

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

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('channel_id', '');
encodedParams.set('group_id', '');
encodedParams.set('team_id', '');
encodedParams.set('token', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.conversations.restrictAccess.addGroup',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('channel_id', '');
encodedParams.set('group_id', '');
encodedParams.set('team_id', '');
encodedParams.set('token', '');

const url = '{{baseUrl}}/admin.conversations.restrictAccess.addGroup';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"channel_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&group_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&team_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&token=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin.conversations.restrictAccess.addGroup"]
                                                       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}}/admin.conversations.restrictAccess.addGroup" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "channel_id=&group_id=&team_id=&token=" in

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

 "{{baseUrl}}/admin.conversations.restrictAccess.addGroup",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "channel_id=&group_id=&team_id=&token=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/admin.conversations.restrictAccess.addGroup', [
  'form_params' => [
    'channel_id' => '',
    'group_id' => '',
    'team_id' => '',
    'token' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin.conversations.restrictAccess.addGroup');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'channel_id' => '',
  'group_id' => '',
  'team_id' => '',
  'token' => ''
]);

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

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

append(new http\QueryString([
  'channel_id' => '',
  'group_id' => '',
  'team_id' => '',
  'token' => ''
]));

$request->setRequestUrl('{{baseUrl}}/admin.conversations.restrictAccess.addGroup');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.conversations.restrictAccess.addGroup' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'channel_id=&group_id=&team_id=&token='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.conversations.restrictAccess.addGroup' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'channel_id=&group_id=&team_id=&token='

import http.client

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

payload = "channel_id=&group_id=&team_id=&token="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/admin.conversations.restrictAccess.addGroup", payload, headers)

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

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

import requests

url = "{{baseUrl}}/admin.conversations.restrictAccess.addGroup"

payload = {
    "channel_id": "",
    "group_id": "",
    "team_id": "",
    "token": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.conversations.restrictAccess.addGroup"

payload <- "channel_id=&group_id=&team_id=&token="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.conversations.restrictAccess.addGroup")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "channel_id=&group_id=&team_id=&token="

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

require 'faraday'

data = {
  :channel_id => "",
  :group_id => "",
  :team_id => "",
  :token => "",
}

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

response = conn.post('/baseUrl/admin.conversations.restrictAccess.addGroup') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.conversations.restrictAccess.addGroup";

    let payload = json!({
        "channel_id": "",
        "group_id": "",
        "team_id": "",
        "token": ""
    });

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

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/admin.conversations.restrictAccess.addGroup \
  content-type:application/x-www-form-urlencoded \
  channel_id='' \
  group_id='' \
  team_id='' \
  token=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'channel_id=&group_id=&team_id=&token=' \
  --output-document \
  - {{baseUrl}}/admin.conversations.restrictAccess.addGroup

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "channel_id=".data(using: String.Encoding.utf8)!)
postData.append("&group_id=".data(using: String.Encoding.utf8)!)
postData.append("&team_id=".data(using: String.Encoding.utf8)!)
postData.append("&token=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.conversations.restrictAccess.addGroup")! 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}}/admin.conversations.restrictAccess.listGroups?token=&channel_id=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/admin.conversations.restrictAccess.listGroups" {:query-params {:token ""
                                                                                                        :channel_id ""}})

require "http/client"

url = "{{baseUrl}}/admin.conversations.restrictAccess.listGroups?token=&channel_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}}/admin.conversations.restrictAccess.listGroups?token=&channel_id="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.conversations.restrictAccess.listGroups?token=&channel_id=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin.conversations.restrictAccess.listGroups?token=&channel_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/admin.conversations.restrictAccess.listGroups?token=&channel_id= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin.conversations.restrictAccess.listGroups?token=&channel_id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.conversations.restrictAccess.listGroups?token=&channel_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}}/admin.conversations.restrictAccess.listGroups?token=&channel_id=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/admin.conversations.restrictAccess.listGroups?token=&channel_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}}/admin.conversations.restrictAccess.listGroups?token=&channel_id=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin.conversations.restrictAccess.listGroups',
  params: {token: '', channel_id: ''}
};

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

const url = '{{baseUrl}}/admin.conversations.restrictAccess.listGroups?token=&channel_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}}/admin.conversations.restrictAccess.listGroups?token=&channel_id=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin.conversations.restrictAccess.listGroups?token=&channel_id=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.conversations.restrictAccess.listGroups?token=&channel_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}}/admin.conversations.restrictAccess.listGroups',
  qs: {token: '', channel_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}}/admin.conversations.restrictAccess.listGroups');

req.query({
  token: '',
  channel_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}}/admin.conversations.restrictAccess.listGroups',
  params: {token: '', channel_id: ''}
};

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

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

const url = '{{baseUrl}}/admin.conversations.restrictAccess.listGroups?token=&channel_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}}/admin.conversations.restrictAccess.listGroups?token=&channel_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}}/admin.conversations.restrictAccess.listGroups?token=&channel_id=" in

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

 "{{baseUrl}}/admin.conversations.restrictAccess.listGroups?token=&channel_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}}/admin.conversations.restrictAccess.listGroups?token=&channel_id=');

echo $response->getBody();

setUrl('{{baseUrl}}/admin.conversations.restrictAccess.listGroups');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'token' => '',
  'channel_id' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/admin.conversations.restrictAccess.listGroups');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'token' => '',
  'channel_id' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.conversations.restrictAccess.listGroups?token=&channel_id=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.conversations.restrictAccess.listGroups?token=&channel_id=' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/admin.conversations.restrictAccess.listGroups?token=&channel_id=")

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

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

import requests

url = "{{baseUrl}}/admin.conversations.restrictAccess.listGroups"

querystring = {"token":"","channel_id":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.conversations.restrictAccess.listGroups"

queryString <- list(
  token = "",
  channel_id = ""
)

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.conversations.restrictAccess.listGroups?token=&channel_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/admin.conversations.restrictAccess.listGroups') do |req|
  req.params['token'] = ''
  req.params['channel_id'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.conversations.restrictAccess.listGroups";

    let querystring = [
        ("token", ""),
        ("channel_id", ""),
    ];

    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}}/admin.conversations.restrictAccess.listGroups?token=&channel_id='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/admin.conversations.restrictAccess.listGroups?token=&channel_id='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.conversations.restrictAccess.listGroups?token=&channel_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, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin.conversations.restrictAccess.removeGroup");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "channel_id=&group_id=&team_id=&token=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/admin.conversations.restrictAccess.removeGroup" {:form-params {:channel_id ""
                                                                                                         :group_id ""
                                                                                                         :team_id ""
                                                                                                         :token ""}})

require "http/client"

url = "{{baseUrl}}/admin.conversations.restrictAccess.removeGroup"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "channel_id=&group_id=&team_id=&token="

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}}/admin.conversations.restrictAccess.removeGroup"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "channel_id", "" },
        { "group_id", "" },
        { "team_id", "" },
        { "token", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.conversations.restrictAccess.removeGroup");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "channel_id=&group_id=&team_id=&token=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin.conversations.restrictAccess.removeGroup"

	payload := strings.NewReader("channel_id=&group_id=&team_id=&token=")

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}

POST /baseUrl/admin.conversations.restrictAccess.removeGroup HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 37

channel_id=&group_id=&team_id=&token=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin.conversations.restrictAccess.removeGroup")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("channel_id=&group_id=&team_id=&token=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.conversations.restrictAccess.removeGroup"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("channel_id=&group_id=&team_id=&token="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "channel_id=&group_id=&team_id=&token=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin.conversations.restrictAccess.removeGroup")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin.conversations.restrictAccess.removeGroup")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("channel_id=&group_id=&team_id=&token=")
  .asString();

const data = 'channel_id=&group_id=&team_id=&token=';

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

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

xhr.open('POST', '{{baseUrl}}/admin.conversations.restrictAccess.removeGroup');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('channel_id', '');
encodedParams.set('group_id', '');
encodedParams.set('team_id', '');
encodedParams.set('token', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.conversations.restrictAccess.removeGroup',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/admin.conversations.restrictAccess.removeGroup';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({channel_id: '', group_id: '', team_id: '', token: ''})
};

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}}/admin.conversations.restrictAccess.removeGroup',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    channel_id: '',
    group_id: '',
    team_id: '',
    token: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "channel_id=&group_id=&team_id=&token=")
val request = Request.Builder()
  .url("{{baseUrl}}/admin.conversations.restrictAccess.removeGroup")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.conversations.restrictAccess.removeGroup',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({channel_id: '', group_id: '', team_id: '', token: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.conversations.restrictAccess.removeGroup',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {channel_id: '', group_id: '', team_id: '', token: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/admin.conversations.restrictAccess.removeGroup');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  channel_id: '',
  group_id: '',
  team_id: '',
  token: ''
});

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

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

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('channel_id', '');
encodedParams.set('group_id', '');
encodedParams.set('team_id', '');
encodedParams.set('token', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.conversations.restrictAccess.removeGroup',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('channel_id', '');
encodedParams.set('group_id', '');
encodedParams.set('team_id', '');
encodedParams.set('token', '');

const url = '{{baseUrl}}/admin.conversations.restrictAccess.removeGroup';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"channel_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&group_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&team_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&token=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin.conversations.restrictAccess.removeGroup"]
                                                       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}}/admin.conversations.restrictAccess.removeGroup" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "channel_id=&group_id=&team_id=&token=" in

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

 "{{baseUrl}}/admin.conversations.restrictAccess.removeGroup",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "channel_id=&group_id=&team_id=&token=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/admin.conversations.restrictAccess.removeGroup', [
  'form_params' => [
    'channel_id' => '',
    'group_id' => '',
    'team_id' => '',
    'token' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin.conversations.restrictAccess.removeGroup');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'channel_id' => '',
  'group_id' => '',
  'team_id' => '',
  'token' => ''
]);

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

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

append(new http\QueryString([
  'channel_id' => '',
  'group_id' => '',
  'team_id' => '',
  'token' => ''
]));

$request->setRequestUrl('{{baseUrl}}/admin.conversations.restrictAccess.removeGroup');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.conversations.restrictAccess.removeGroup' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'channel_id=&group_id=&team_id=&token='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.conversations.restrictAccess.removeGroup' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'channel_id=&group_id=&team_id=&token='

import http.client

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

payload = "channel_id=&group_id=&team_id=&token="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/admin.conversations.restrictAccess.removeGroup", payload, headers)

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

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

import requests

url = "{{baseUrl}}/admin.conversations.restrictAccess.removeGroup"

payload = {
    "channel_id": "",
    "group_id": "",
    "team_id": "",
    "token": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.conversations.restrictAccess.removeGroup"

payload <- "channel_id=&group_id=&team_id=&token="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.conversations.restrictAccess.removeGroup")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "channel_id=&group_id=&team_id=&token="

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

require 'faraday'

data = {
  :channel_id => "",
  :group_id => "",
  :team_id => "",
  :token => "",
}

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

response = conn.post('/baseUrl/admin.conversations.restrictAccess.removeGroup') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.conversations.restrictAccess.removeGroup";

    let payload = json!({
        "channel_id": "",
        "group_id": "",
        "team_id": "",
        "token": ""
    });

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

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/admin.conversations.restrictAccess.removeGroup \
  content-type:application/x-www-form-urlencoded \
  channel_id='' \
  group_id='' \
  team_id='' \
  token=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'channel_id=&group_id=&team_id=&token=' \
  --output-document \
  - {{baseUrl}}/admin.conversations.restrictAccess.removeGroup

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "channel_id=".data(using: String.Encoding.utf8)!)
postData.append("&group_id=".data(using: String.Encoding.utf8)!)
postData.append("&team_id=".data(using: String.Encoding.utf8)!)
postData.append("&token=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.conversations.restrictAccess.removeGroup")! 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}}/admin.emoji.add");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "name=&token=&url=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/admin.emoji.add" {:form-params {:name ""
                                                                          :token ""
                                                                          :url ""}})

require "http/client"

url = "{{baseUrl}}/admin.emoji.add"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "name=&token=&url="

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}}/admin.emoji.add"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "name", "" },
        { "token", "" },
        { "url", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.emoji.add");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "name=&token=&url=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin.emoji.add"

	payload := strings.NewReader("name=&token=&url=")

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}

POST /baseUrl/admin.emoji.add HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 17

name=&token=&url=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin.emoji.add")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("name=&token=&url=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.emoji.add"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("name=&token=&url="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "name=&token=&url=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin.emoji.add")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin.emoji.add")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("name=&token=&url=")
  .asString();

const data = 'name=&token=&url=';

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

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

xhr.open('POST', '{{baseUrl}}/admin.emoji.add');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('name', '');
encodedParams.set('token', '');
encodedParams.set('url', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.emoji.add',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/admin.emoji.add';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({name: '', token: '', url: ''})
};

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}}/admin.emoji.add',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    name: '',
    token: '',
    url: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "name=&token=&url=")
val request = Request.Builder()
  .url("{{baseUrl}}/admin.emoji.add")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.emoji.add',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({name: '', token: '', url: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.emoji.add',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {name: '', token: '', url: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/admin.emoji.add');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  name: '',
  token: '',
  url: ''
});

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

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

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('name', '');
encodedParams.set('token', '');
encodedParams.set('url', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.emoji.add',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('name', '');
encodedParams.set('token', '');
encodedParams.set('url', '');

const url = '{{baseUrl}}/admin.emoji.add';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"name=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&token=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&url=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin.emoji.add"]
                                                       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}}/admin.emoji.add" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "name=&token=&url=" in

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

 "{{baseUrl}}/admin.emoji.add",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "name=&token=&url=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/admin.emoji.add', [
  'form_params' => [
    'name' => '',
    'token' => '',
    'url' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin.emoji.add');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'name' => '',
  'token' => '',
  'url' => ''
]);

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

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

append(new http\QueryString([
  'name' => '',
  'token' => '',
  'url' => ''
]));

$request->setRequestUrl('{{baseUrl}}/admin.emoji.add');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.emoji.add' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'name=&token=&url='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.emoji.add' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'name=&token=&url='

import http.client

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

payload = "name=&token=&url="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/admin.emoji.add", payload, headers)

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

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

import requests

url = "{{baseUrl}}/admin.emoji.add"

payload = {
    "name": "",
    "token": "",
    "url": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.emoji.add"

payload <- "name=&token=&url="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.emoji.add")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "name=&token=&url="

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

require 'faraday'

data = {
  :name => "",
  :token => "",
  :url => "",
}

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

response = conn.post('/baseUrl/admin.emoji.add') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.emoji.add";

    let payload = json!({
        "name": "",
        "token": "",
        "url": ""
    });

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

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/admin.emoji.add \
  content-type:application/x-www-form-urlencoded \
  name='' \
  token='' \
  url=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'name=&token=&url=' \
  --output-document \
  - {{baseUrl}}/admin.emoji.add

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "name=".data(using: String.Encoding.utf8)!)
postData.append("&token=".data(using: String.Encoding.utf8)!)
postData.append("&url=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.emoji.add")! 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}}/admin.emoji.addAlias");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "alias_for=&name=&token=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/admin.emoji.addAlias" {:form-params {:alias_for ""
                                                                               :name ""
                                                                               :token ""}})

require "http/client"

url = "{{baseUrl}}/admin.emoji.addAlias"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "alias_for=&name=&token="

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}}/admin.emoji.addAlias"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "alias_for", "" },
        { "name", "" },
        { "token", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.emoji.addAlias");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "alias_for=&name=&token=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin.emoji.addAlias"

	payload := strings.NewReader("alias_for=&name=&token=")

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}

POST /baseUrl/admin.emoji.addAlias HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 23

alias_for=&name=&token=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin.emoji.addAlias")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("alias_for=&name=&token=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.emoji.addAlias"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("alias_for=&name=&token="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "alias_for=&name=&token=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin.emoji.addAlias")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin.emoji.addAlias")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("alias_for=&name=&token=")
  .asString();

const data = 'alias_for=&name=&token=';

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

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

xhr.open('POST', '{{baseUrl}}/admin.emoji.addAlias');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('alias_for', '');
encodedParams.set('name', '');
encodedParams.set('token', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.emoji.addAlias',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/admin.emoji.addAlias';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({alias_for: '', name: '', token: ''})
};

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}}/admin.emoji.addAlias',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    alias_for: '',
    name: '',
    token: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "alias_for=&name=&token=")
val request = Request.Builder()
  .url("{{baseUrl}}/admin.emoji.addAlias")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.emoji.addAlias',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({alias_for: '', name: '', token: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.emoji.addAlias',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {alias_for: '', name: '', token: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/admin.emoji.addAlias');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  alias_for: '',
  name: '',
  token: ''
});

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

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

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('alias_for', '');
encodedParams.set('name', '');
encodedParams.set('token', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.emoji.addAlias',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('alias_for', '');
encodedParams.set('name', '');
encodedParams.set('token', '');

const url = '{{baseUrl}}/admin.emoji.addAlias';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"alias_for=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&name=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&token=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin.emoji.addAlias"]
                                                       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}}/admin.emoji.addAlias" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "alias_for=&name=&token=" in

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

 "{{baseUrl}}/admin.emoji.addAlias",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "alias_for=&name=&token=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/admin.emoji.addAlias', [
  'form_params' => [
    'alias_for' => '',
    'name' => '',
    'token' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin.emoji.addAlias');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'alias_for' => '',
  'name' => '',
  'token' => ''
]);

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

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

append(new http\QueryString([
  'alias_for' => '',
  'name' => '',
  'token' => ''
]));

$request->setRequestUrl('{{baseUrl}}/admin.emoji.addAlias');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.emoji.addAlias' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'alias_for=&name=&token='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.emoji.addAlias' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'alias_for=&name=&token='

import http.client

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

payload = "alias_for=&name=&token="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/admin.emoji.addAlias", payload, headers)

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

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

import requests

url = "{{baseUrl}}/admin.emoji.addAlias"

payload = {
    "alias_for": "",
    "name": "",
    "token": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.emoji.addAlias"

payload <- "alias_for=&name=&token="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.emoji.addAlias")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "alias_for=&name=&token="

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

require 'faraday'

data = {
  :alias_for => "",
  :name => "",
  :token => "",
}

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

response = conn.post('/baseUrl/admin.emoji.addAlias') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.emoji.addAlias";

    let payload = json!({
        "alias_for": "",
        "name": "",
        "token": ""
    });

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

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/admin.emoji.addAlias \
  content-type:application/x-www-form-urlencoded \
  alias_for='' \
  name='' \
  token=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'alias_for=&name=&token=' \
  --output-document \
  - {{baseUrl}}/admin.emoji.addAlias

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "alias_for=".data(using: String.Encoding.utf8)!)
postData.append("&name=".data(using: String.Encoding.utf8)!)
postData.append("&token=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.emoji.addAlias")! 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}}/admin.emoji.list?token=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/admin.emoji.list" {:query-params {:token ""}})

require "http/client"

url = "{{baseUrl}}/admin.emoji.list?token="

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}}/admin.emoji.list?token="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.emoji.list?token=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin.emoji.list?token="

	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/admin.emoji.list?token= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin.emoji.list?token=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.emoji.list?token="))
    .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}}/admin.emoji.list?token=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/admin.emoji.list?token=")
  .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}}/admin.emoji.list?token=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin.emoji.list',
  params: {token: ''}
};

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

const url = '{{baseUrl}}/admin.emoji.list?token=';
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}}/admin.emoji.list?token=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin.emoji.list?token=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.emoji.list?token=',
  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}}/admin.emoji.list',
  qs: {token: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/admin.emoji.list');

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

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}}/admin.emoji.list',
  params: {token: ''}
};

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

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

const url = '{{baseUrl}}/admin.emoji.list?token=';
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}}/admin.emoji.list?token="]
                                                       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}}/admin.emoji.list?token=" in

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

 "{{baseUrl}}/admin.emoji.list?token=",
  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}}/admin.emoji.list?token=');

echo $response->getBody();

setUrl('{{baseUrl}}/admin.emoji.list');
$request->setMethod(HTTP_METH_GET);

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

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

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

setRequestUrl('{{baseUrl}}/admin.emoji.list');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'token' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.emoji.list?token=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.emoji.list?token=' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/admin.emoji.list?token=")

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

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

import requests

url = "{{baseUrl}}/admin.emoji.list"

querystring = {"token":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.emoji.list"

queryString <- list(token = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.emoji.list?token=")

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/admin.emoji.list') do |req|
  req.params['token'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.emoji.list";

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

    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}}/admin.emoji.list?token='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/admin.emoji.list?token='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.emoji.list?token=")! 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}}/admin.emoji.remove");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "name=&token=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/admin.emoji.remove" {:form-params {:name ""
                                                                             :token ""}})

require "http/client"

url = "{{baseUrl}}/admin.emoji.remove"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "name=&token="

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}}/admin.emoji.remove"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "name", "" },
        { "token", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.emoji.remove");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "name=&token=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin.emoji.remove"

	payload := strings.NewReader("name=&token=")

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}

POST /baseUrl/admin.emoji.remove HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 12

name=&token=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin.emoji.remove")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("name=&token=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.emoji.remove"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("name=&token="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "name=&token=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin.emoji.remove")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin.emoji.remove")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("name=&token=")
  .asString();

const data = 'name=&token=';

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

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

xhr.open('POST', '{{baseUrl}}/admin.emoji.remove');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('name', '');
encodedParams.set('token', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.emoji.remove',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/admin.emoji.remove';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({name: '', token: ''})
};

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}}/admin.emoji.remove',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    name: '',
    token: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "name=&token=")
val request = Request.Builder()
  .url("{{baseUrl}}/admin.emoji.remove")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.emoji.remove',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({name: '', token: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.emoji.remove',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {name: '', token: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/admin.emoji.remove');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  name: '',
  token: ''
});

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

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

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('name', '');
encodedParams.set('token', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.emoji.remove',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('name', '');
encodedParams.set('token', '');

const url = '{{baseUrl}}/admin.emoji.remove';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"name=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&token=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin.emoji.remove"]
                                                       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}}/admin.emoji.remove" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "name=&token=" in

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

 "{{baseUrl}}/admin.emoji.remove",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "name=&token=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/admin.emoji.remove', [
  'form_params' => [
    'name' => '',
    'token' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin.emoji.remove');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'name' => '',
  'token' => ''
]);

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

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

append(new http\QueryString([
  'name' => '',
  'token' => ''
]));

$request->setRequestUrl('{{baseUrl}}/admin.emoji.remove');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.emoji.remove' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'name=&token='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.emoji.remove' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'name=&token='

import http.client

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

payload = "name=&token="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/admin.emoji.remove", payload, headers)

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

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

import requests

url = "{{baseUrl}}/admin.emoji.remove"

payload = {
    "name": "",
    "token": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.emoji.remove"

payload <- "name=&token="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.emoji.remove")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "name=&token="

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

require 'faraday'

data = {
  :name => "",
  :token => "",
}

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

response = conn.post('/baseUrl/admin.emoji.remove') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.emoji.remove";

    let payload = json!({
        "name": "",
        "token": ""
    });

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

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/admin.emoji.remove \
  content-type:application/x-www-form-urlencoded \
  name='' \
  token=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'name=&token=' \
  --output-document \
  - {{baseUrl}}/admin.emoji.remove

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "name=".data(using: String.Encoding.utf8)!)
postData.append("&token=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.emoji.remove")! 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}}/admin.emoji.rename");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "name=&new_name=&token=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/admin.emoji.rename" {:form-params {:name ""
                                                                             :new_name ""
                                                                             :token ""}})

require "http/client"

url = "{{baseUrl}}/admin.emoji.rename"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "name=&new_name=&token="

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}}/admin.emoji.rename"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "name", "" },
        { "new_name", "" },
        { "token", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.emoji.rename");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "name=&new_name=&token=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin.emoji.rename"

	payload := strings.NewReader("name=&new_name=&token=")

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}

POST /baseUrl/admin.emoji.rename HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 22

name=&new_name=&token=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin.emoji.rename")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("name=&new_name=&token=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.emoji.rename"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("name=&new_name=&token="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "name=&new_name=&token=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin.emoji.rename")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin.emoji.rename")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("name=&new_name=&token=")
  .asString();

const data = 'name=&new_name=&token=';

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

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

xhr.open('POST', '{{baseUrl}}/admin.emoji.rename');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('name', '');
encodedParams.set('new_name', '');
encodedParams.set('token', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.emoji.rename',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/admin.emoji.rename';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({name: '', new_name: '', token: ''})
};

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}}/admin.emoji.rename',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    name: '',
    new_name: '',
    token: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "name=&new_name=&token=")
val request = Request.Builder()
  .url("{{baseUrl}}/admin.emoji.rename")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.emoji.rename',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({name: '', new_name: '', token: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.emoji.rename',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {name: '', new_name: '', token: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/admin.emoji.rename');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  name: '',
  new_name: '',
  token: ''
});

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

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

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('name', '');
encodedParams.set('new_name', '');
encodedParams.set('token', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.emoji.rename',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('name', '');
encodedParams.set('new_name', '');
encodedParams.set('token', '');

const url = '{{baseUrl}}/admin.emoji.rename';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"name=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&new_name=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&token=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin.emoji.rename"]
                                                       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}}/admin.emoji.rename" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "name=&new_name=&token=" in

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

 "{{baseUrl}}/admin.emoji.rename",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "name=&new_name=&token=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/admin.emoji.rename', [
  'form_params' => [
    'name' => '',
    'new_name' => '',
    'token' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin.emoji.rename');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'name' => '',
  'new_name' => '',
  'token' => ''
]);

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

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

append(new http\QueryString([
  'name' => '',
  'new_name' => '',
  'token' => ''
]));

$request->setRequestUrl('{{baseUrl}}/admin.emoji.rename');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.emoji.rename' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'name=&new_name=&token='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.emoji.rename' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'name=&new_name=&token='

import http.client

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

payload = "name=&new_name=&token="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/admin.emoji.rename", payload, headers)

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

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

import requests

url = "{{baseUrl}}/admin.emoji.rename"

payload = {
    "name": "",
    "new_name": "",
    "token": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.emoji.rename"

payload <- "name=&new_name=&token="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.emoji.rename")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "name=&new_name=&token="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :name => "",
  :new_name => "",
  :token => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/admin.emoji.rename') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.emoji.rename";

    let payload = json!({
        "name": "",
        "new_name": "",
        "token": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http --form POST {{baseUrl}}/admin.emoji.rename \
  content-type:application/x-www-form-urlencoded \
  name='' \
  new_name='' \
  token=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'name=&new_name=&token=' \
  --output-document \
  - {{baseUrl}}/admin.emoji.rename

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "name=".data(using: String.Encoding.utf8)!)
postData.append("&new_name=".data(using: String.Encoding.utf8)!)
postData.append("&token=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.emoji.rename")! 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}}/admin.inviteRequests.approve");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "token: ");
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "invite_request_id=&team_id=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/admin.inviteRequests.approve" {:headers {:token ""}
                                                                         :form-params {:invite_request_id ""
                                                                                       :team_id ""}})

require "http/client"

url = "{{baseUrl}}/admin.inviteRequests.approve"
headers = HTTP::Headers{
  "token" => ""
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "invite_request_id=&team_id="

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}}/admin.inviteRequests.approve"),
    Headers =
    {
        { "token", "" },
    },
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "invite_request_id", "" },
        { "team_id", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.inviteRequests.approve");
var request = new RestRequest("", Method.Post);
request.AddHeader("token", "");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "invite_request_id=&team_id=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/admin.inviteRequests.approve"

	payload := strings.NewReader("invite_request_id=&team_id=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("token", "")
	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/admin.inviteRequests.approve HTTP/1.1
Token: 
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 27

invite_request_id=&team_id=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin.inviteRequests.approve")
  .setHeader("token", "")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("invite_request_id=&team_id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.inviteRequests.approve"))
    .header("token", "")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("invite_request_id=&team_id="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "invite_request_id=&team_id=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin.inviteRequests.approve")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/admin.inviteRequests.approve")
  .header("token", "")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("invite_request_id=&team_id=")
  .asString();

const data = 'invite_request_id=&team_id=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/admin.inviteRequests.approve');
xhr.setRequestHeader('token', '');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('invite_request_id', '');
encodedParams.set('team_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.inviteRequests.approve',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/admin.inviteRequests.approve';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({invite_request_id: '', team_id: ''})
};

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}}/admin.inviteRequests.approve',
  method: 'POST',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    invite_request_id: '',
    team_id: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "invite_request_id=&team_id=")
val request = Request.Builder()
  .url("{{baseUrl}}/admin.inviteRequests.approve")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.inviteRequests.approve',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({invite_request_id: '', team_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.inviteRequests.approve',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  form: {invite_request_id: '', team_id: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/admin.inviteRequests.approve');

req.headers({
  token: '',
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  invite_request_id: '',
  team_id: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('invite_request_id', '');
encodedParams.set('team_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.inviteRequests.approve',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('invite_request_id', '');
encodedParams.set('team_id', '');

const url = '{{baseUrl}}/admin.inviteRequests.approve';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"token": @"",
                           @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"invite_request_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&team_id=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin.inviteRequests.approve"]
                                                       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}}/admin.inviteRequests.approve" in
let headers = Header.add_list (Header.init ()) [
  ("token", "");
  ("content-type", "application/x-www-form-urlencoded");
] in
let body = Cohttp_lwt_body.of_string "invite_request_id=&team_id=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/admin.inviteRequests.approve",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "invite_request_id=&team_id=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "token: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/admin.inviteRequests.approve', [
  'form_params' => [
    'invite_request_id' => '',
    'team_id' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin.inviteRequests.approve');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'invite_request_id' => '',
  'team_id' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'invite_request_id' => '',
  'team_id' => ''
]));

$request->setRequestUrl('{{baseUrl}}/admin.inviteRequests.approve');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.inviteRequests.approve' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'invite_request_id=&team_id='

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.inviteRequests.approve' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'invite_request_id=&team_id='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "invite_request_id=&team_id="

headers = {
    'token': "",
    'content-type': "application/x-www-form-urlencoded"
}

conn.request("POST", "/baseUrl/admin.inviteRequests.approve", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/admin.inviteRequests.approve"

payload = {
    "invite_request_id": "",
    "team_id": ""
}
headers = {
    "token": "",
    "content-type": "application/x-www-form-urlencoded"
}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.inviteRequests.approve"

payload <- "invite_request_id=&team_id="

encode <- "form"

response <- VERB("POST", url, body = payload, add_headers('token' = ''), content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.inviteRequests.approve")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["token"] = ''
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "invite_request_id=&team_id="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :invite_request_id => "",
  :team_id => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/admin.inviteRequests.approve') do |req|
  req.headers['token'] = ''
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.inviteRequests.approve";

    let payload = json!({
        "invite_request_id": "",
        "team_id": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("token", "".parse().unwrap());
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http --form POST {{baseUrl}}/admin.inviteRequests.approve \
  content-type:application/x-www-form-urlencoded \
  token:'' \
  invite_request_id='' \
  team_id=''

wget --quiet \
  --method POST \
  --header 'token: ' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'invite_request_id=&team_id=' \
  --output-document \
  - {{baseUrl}}/admin.inviteRequests.approve

import Foundation

let headers = [
  "token": "",
  "content-type": "application/x-www-form-urlencoded"
]

let postData = NSMutableData(data: "invite_request_id=".data(using: String.Encoding.utf8)!)
postData.append("&team_id=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.inviteRequests.approve")! 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}}/admin.inviteRequests.deny");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "token: ");
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "invite_request_id=&team_id=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/admin.inviteRequests.deny" {:headers {:token ""}
                                                                      :form-params {:invite_request_id ""
                                                                                    :team_id ""}})

require "http/client"

url = "{{baseUrl}}/admin.inviteRequests.deny"
headers = HTTP::Headers{
  "token" => ""
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "invite_request_id=&team_id="

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}}/admin.inviteRequests.deny"),
    Headers =
    {
        { "token", "" },
    },
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "invite_request_id", "" },
        { "team_id", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.inviteRequests.deny");
var request = new RestRequest("", Method.Post);
request.AddHeader("token", "");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "invite_request_id=&team_id=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/admin.inviteRequests.deny"

	payload := strings.NewReader("invite_request_id=&team_id=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("token", "")
	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/admin.inviteRequests.deny HTTP/1.1
Token: 
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 27

invite_request_id=&team_id=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin.inviteRequests.deny")
  .setHeader("token", "")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("invite_request_id=&team_id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.inviteRequests.deny"))
    .header("token", "")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("invite_request_id=&team_id="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "invite_request_id=&team_id=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin.inviteRequests.deny")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/admin.inviteRequests.deny")
  .header("token", "")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("invite_request_id=&team_id=")
  .asString();

const data = 'invite_request_id=&team_id=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/admin.inviteRequests.deny');
xhr.setRequestHeader('token', '');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('invite_request_id', '');
encodedParams.set('team_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.inviteRequests.deny',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/admin.inviteRequests.deny';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({invite_request_id: '', team_id: ''})
};

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}}/admin.inviteRequests.deny',
  method: 'POST',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    invite_request_id: '',
    team_id: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "invite_request_id=&team_id=")
val request = Request.Builder()
  .url("{{baseUrl}}/admin.inviteRequests.deny")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.inviteRequests.deny',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({invite_request_id: '', team_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.inviteRequests.deny',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  form: {invite_request_id: '', team_id: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/admin.inviteRequests.deny');

req.headers({
  token: '',
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  invite_request_id: '',
  team_id: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('invite_request_id', '');
encodedParams.set('team_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.inviteRequests.deny',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('invite_request_id', '');
encodedParams.set('team_id', '');

const url = '{{baseUrl}}/admin.inviteRequests.deny';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"token": @"",
                           @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"invite_request_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&team_id=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin.inviteRequests.deny"]
                                                       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}}/admin.inviteRequests.deny" in
let headers = Header.add_list (Header.init ()) [
  ("token", "");
  ("content-type", "application/x-www-form-urlencoded");
] in
let body = Cohttp_lwt_body.of_string "invite_request_id=&team_id=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/admin.inviteRequests.deny",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "invite_request_id=&team_id=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "token: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/admin.inviteRequests.deny', [
  'form_params' => [
    'invite_request_id' => '',
    'team_id' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin.inviteRequests.deny');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'invite_request_id' => '',
  'team_id' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'invite_request_id' => '',
  'team_id' => ''
]));

$request->setRequestUrl('{{baseUrl}}/admin.inviteRequests.deny');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.inviteRequests.deny' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'invite_request_id=&team_id='

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.inviteRequests.deny' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'invite_request_id=&team_id='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "invite_request_id=&team_id="

headers = {
    'token': "",
    'content-type': "application/x-www-form-urlencoded"
}

conn.request("POST", "/baseUrl/admin.inviteRequests.deny", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/admin.inviteRequests.deny"

payload = {
    "invite_request_id": "",
    "team_id": ""
}
headers = {
    "token": "",
    "content-type": "application/x-www-form-urlencoded"
}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.inviteRequests.deny"

payload <- "invite_request_id=&team_id="

encode <- "form"

response <- VERB("POST", url, body = payload, add_headers('token' = ''), content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.inviteRequests.deny")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["token"] = ''
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "invite_request_id=&team_id="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :invite_request_id => "",
  :team_id => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/admin.inviteRequests.deny') do |req|
  req.headers['token'] = ''
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.inviteRequests.deny";

    let payload = json!({
        "invite_request_id": "",
        "team_id": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("token", "".parse().unwrap());
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http --form POST {{baseUrl}}/admin.inviteRequests.deny \
  content-type:application/x-www-form-urlencoded \
  token:'' \
  invite_request_id='' \
  team_id=''

wget --quiet \
  --method POST \
  --header 'token: ' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'invite_request_id=&team_id=' \
  --output-document \
  - {{baseUrl}}/admin.inviteRequests.deny

import Foundation

let headers = [
  "token": "",
  "content-type": "application/x-www-form-urlencoded"
]

let postData = NSMutableData(data: "invite_request_id=".data(using: String.Encoding.utf8)!)
postData.append("&team_id=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.inviteRequests.deny")! 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}}/admin.inviteRequests.list");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/admin.inviteRequests.list" {:headers {:token ""}})

require "http/client"

url = "{{baseUrl}}/admin.inviteRequests.list"
headers = HTTP::Headers{
  "token" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/admin.inviteRequests.list"),
    Headers =
    {
        { "token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.inviteRequests.list");
var request = new RestRequest("", Method.Get);
request.AddHeader("token", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/admin.inviteRequests.list"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("token", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/admin.inviteRequests.list HTTP/1.1
Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin.inviteRequests.list")
  .setHeader("token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.inviteRequests.list"))
    .header("token", "")
    .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}}/admin.inviteRequests.list")
  .get()
  .addHeader("token", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/admin.inviteRequests.list")
  .header("token", "")
  .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}}/admin.inviteRequests.list');
xhr.setRequestHeader('token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin.inviteRequests.list',
  headers: {token: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/admin.inviteRequests.list';
const options = {method: 'GET', headers: {token: ''}};

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}}/admin.inviteRequests.list',
  method: 'GET',
  headers: {
    token: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin.inviteRequests.list")
  .get()
  .addHeader("token", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.inviteRequests.list',
  headers: {
    token: ''
  }
};

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}}/admin.inviteRequests.list',
  headers: {token: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/admin.inviteRequests.list');

req.headers({
  token: ''
});

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}}/admin.inviteRequests.list',
  headers: {token: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/admin.inviteRequests.list';
const options = {method: 'GET', headers: {token: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin.inviteRequests.list"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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}}/admin.inviteRequests.list" in
let headers = Header.add (Header.init ()) "token" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/admin.inviteRequests.list",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "token: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/admin.inviteRequests.list', [
  'headers' => [
    'token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin.inviteRequests.list');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'token' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/admin.inviteRequests.list');
$request->setRequestMethod('GET');
$request->setHeaders([
  'token' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.inviteRequests.list' -Method GET -Headers $headers

$headers=@{}
$headers.Add("token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.inviteRequests.list' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'token': "" }

conn.request("GET", "/baseUrl/admin.inviteRequests.list", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/admin.inviteRequests.list"

headers = {"token": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.inviteRequests.list"

response <- VERB("GET", url, add_headers('token' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.inviteRequests.list")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["token"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/admin.inviteRequests.list') do |req|
  req.headers['token'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.inviteRequests.list";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("token", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/admin.inviteRequests.list \
  token:''

wget --quiet \
  --method GET \
  --header 'token: ' \
  --output-document \
  - {{baseUrl}}/admin.inviteRequests.list

import Foundation

let headers = ["token": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.inviteRequests.list")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin.inviteRequests.approved.list");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/admin.inviteRequests.approved.list" {:headers {:token ""}})

require "http/client"

url = "{{baseUrl}}/admin.inviteRequests.approved.list"
headers = HTTP::Headers{
  "token" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/admin.inviteRequests.approved.list"),
    Headers =
    {
        { "token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.inviteRequests.approved.list");
var request = new RestRequest("", Method.Get);
request.AddHeader("token", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/admin.inviteRequests.approved.list"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("token", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/admin.inviteRequests.approved.list HTTP/1.1
Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin.inviteRequests.approved.list")
  .setHeader("token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.inviteRequests.approved.list"))
    .header("token", "")
    .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}}/admin.inviteRequests.approved.list")
  .get()
  .addHeader("token", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/admin.inviteRequests.approved.list")
  .header("token", "")
  .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}}/admin.inviteRequests.approved.list');
xhr.setRequestHeader('token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin.inviteRequests.approved.list',
  headers: {token: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/admin.inviteRequests.approved.list';
const options = {method: 'GET', headers: {token: ''}};

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}}/admin.inviteRequests.approved.list',
  method: 'GET',
  headers: {
    token: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin.inviteRequests.approved.list")
  .get()
  .addHeader("token", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.inviteRequests.approved.list',
  headers: {
    token: ''
  }
};

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}}/admin.inviteRequests.approved.list',
  headers: {token: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/admin.inviteRequests.approved.list');

req.headers({
  token: ''
});

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}}/admin.inviteRequests.approved.list',
  headers: {token: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/admin.inviteRequests.approved.list';
const options = {method: 'GET', headers: {token: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin.inviteRequests.approved.list"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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}}/admin.inviteRequests.approved.list" in
let headers = Header.add (Header.init ()) "token" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/admin.inviteRequests.approved.list",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "token: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/admin.inviteRequests.approved.list', [
  'headers' => [
    'token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin.inviteRequests.approved.list');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'token' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/admin.inviteRequests.approved.list');
$request->setRequestMethod('GET');
$request->setHeaders([
  'token' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.inviteRequests.approved.list' -Method GET -Headers $headers

$headers=@{}
$headers.Add("token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.inviteRequests.approved.list' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'token': "" }

conn.request("GET", "/baseUrl/admin.inviteRequests.approved.list", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/admin.inviteRequests.approved.list"

headers = {"token": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.inviteRequests.approved.list"

response <- VERB("GET", url, add_headers('token' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.inviteRequests.approved.list")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["token"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/admin.inviteRequests.approved.list') do |req|
  req.headers['token'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.inviteRequests.approved.list";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("token", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/admin.inviteRequests.approved.list \
  token:''

wget --quiet \
  --method GET \
  --header 'token: ' \
  --output-document \
  - {{baseUrl}}/admin.inviteRequests.approved.list

import Foundation

let headers = ["token": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.inviteRequests.approved.list")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin.inviteRequests.denied.list");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/admin.inviteRequests.denied.list" {:headers {:token ""}})

require "http/client"

url = "{{baseUrl}}/admin.inviteRequests.denied.list"
headers = HTTP::Headers{
  "token" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/admin.inviteRequests.denied.list"),
    Headers =
    {
        { "token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.inviteRequests.denied.list");
var request = new RestRequest("", Method.Get);
request.AddHeader("token", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/admin.inviteRequests.denied.list"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("token", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/admin.inviteRequests.denied.list HTTP/1.1
Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin.inviteRequests.denied.list")
  .setHeader("token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.inviteRequests.denied.list"))
    .header("token", "")
    .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}}/admin.inviteRequests.denied.list")
  .get()
  .addHeader("token", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/admin.inviteRequests.denied.list")
  .header("token", "")
  .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}}/admin.inviteRequests.denied.list');
xhr.setRequestHeader('token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin.inviteRequests.denied.list',
  headers: {token: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/admin.inviteRequests.denied.list';
const options = {method: 'GET', headers: {token: ''}};

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}}/admin.inviteRequests.denied.list',
  method: 'GET',
  headers: {
    token: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin.inviteRequests.denied.list")
  .get()
  .addHeader("token", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.inviteRequests.denied.list',
  headers: {
    token: ''
  }
};

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}}/admin.inviteRequests.denied.list',
  headers: {token: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/admin.inviteRequests.denied.list');

req.headers({
  token: ''
});

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}}/admin.inviteRequests.denied.list',
  headers: {token: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/admin.inviteRequests.denied.list';
const options = {method: 'GET', headers: {token: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin.inviteRequests.denied.list"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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}}/admin.inviteRequests.denied.list" in
let headers = Header.add (Header.init ()) "token" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/admin.inviteRequests.denied.list",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "token: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/admin.inviteRequests.denied.list', [
  'headers' => [
    'token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin.inviteRequests.denied.list');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'token' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/admin.inviteRequests.denied.list');
$request->setRequestMethod('GET');
$request->setHeaders([
  'token' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.inviteRequests.denied.list' -Method GET -Headers $headers

$headers=@{}
$headers.Add("token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.inviteRequests.denied.list' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'token': "" }

conn.request("GET", "/baseUrl/admin.inviteRequests.denied.list", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/admin.inviteRequests.denied.list"

headers = {"token": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.inviteRequests.denied.list"

response <- VERB("GET", url, add_headers('token' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.inviteRequests.denied.list")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["token"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/admin.inviteRequests.denied.list') do |req|
  req.headers['token'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.inviteRequests.denied.list";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("token", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/admin.inviteRequests.denied.list \
  token:''

wget --quiet \
  --method GET \
  --header 'token: ' \
  --output-document \
  - {{baseUrl}}/admin.inviteRequests.denied.list

import Foundation

let headers = ["token": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.inviteRequests.denied.list")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin.teams.create");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "token: ");
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "team_description=&team_discoverability=&team_domain=&team_name=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/admin.teams.create" {:headers {:token ""}
                                                               :form-params {:team_description ""
                                                                             :team_discoverability ""
                                                                             :team_domain ""
                                                                             :team_name ""}})

require "http/client"

url = "{{baseUrl}}/admin.teams.create"
headers = HTTP::Headers{
  "token" => ""
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "team_description=&team_discoverability=&team_domain=&team_name="

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}}/admin.teams.create"),
    Headers =
    {
        { "token", "" },
    },
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "team_description", "" },
        { "team_discoverability", "" },
        { "team_domain", "" },
        { "team_name", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.teams.create");
var request = new RestRequest("", Method.Post);
request.AddHeader("token", "");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "team_description=&team_discoverability=&team_domain=&team_name=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/admin.teams.create"

	payload := strings.NewReader("team_description=&team_discoverability=&team_domain=&team_name=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("token", "")
	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/admin.teams.create HTTP/1.1
Token: 
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 63

team_description=&team_discoverability=&team_domain=&team_name=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin.teams.create")
  .setHeader("token", "")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("team_description=&team_discoverability=&team_domain=&team_name=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.teams.create"))
    .header("token", "")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("team_description=&team_discoverability=&team_domain=&team_name="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "team_description=&team_discoverability=&team_domain=&team_name=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin.teams.create")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/admin.teams.create")
  .header("token", "")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("team_description=&team_discoverability=&team_domain=&team_name=")
  .asString();

const data = 'team_description=&team_discoverability=&team_domain=&team_name=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/admin.teams.create');
xhr.setRequestHeader('token', '');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('team_description', '');
encodedParams.set('team_discoverability', '');
encodedParams.set('team_domain', '');
encodedParams.set('team_name', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.teams.create',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/admin.teams.create';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({team_description: '', team_discoverability: '', team_domain: '', team_name: ''})
};

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}}/admin.teams.create',
  method: 'POST',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    team_description: '',
    team_discoverability: '',
    team_domain: '',
    team_name: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "team_description=&team_discoverability=&team_domain=&team_name=")
val request = Request.Builder()
  .url("{{baseUrl}}/admin.teams.create")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.teams.create',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({team_description: '', team_discoverability: '', team_domain: '', team_name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.teams.create',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  form: {team_description: '', team_discoverability: '', team_domain: '', team_name: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/admin.teams.create');

req.headers({
  token: '',
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  team_description: '',
  team_discoverability: '',
  team_domain: '',
  team_name: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('team_description', '');
encodedParams.set('team_discoverability', '');
encodedParams.set('team_domain', '');
encodedParams.set('team_name', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.teams.create',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('team_description', '');
encodedParams.set('team_discoverability', '');
encodedParams.set('team_domain', '');
encodedParams.set('team_name', '');

const url = '{{baseUrl}}/admin.teams.create';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"token": @"",
                           @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"team_description=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&team_discoverability=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&team_domain=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&team_name=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin.teams.create"]
                                                       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}}/admin.teams.create" in
let headers = Header.add_list (Header.init ()) [
  ("token", "");
  ("content-type", "application/x-www-form-urlencoded");
] in
let body = Cohttp_lwt_body.of_string "team_description=&team_discoverability=&team_domain=&team_name=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/admin.teams.create",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "team_description=&team_discoverability=&team_domain=&team_name=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "token: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/admin.teams.create', [
  'form_params' => [
    'team_description' => '',
    'team_discoverability' => '',
    'team_domain' => '',
    'team_name' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin.teams.create');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'team_description' => '',
  'team_discoverability' => '',
  'team_domain' => '',
  'team_name' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'team_description' => '',
  'team_discoverability' => '',
  'team_domain' => '',
  'team_name' => ''
]));

$request->setRequestUrl('{{baseUrl}}/admin.teams.create');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.teams.create' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'team_description=&team_discoverability=&team_domain=&team_name='

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.teams.create' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'team_description=&team_discoverability=&team_domain=&team_name='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "team_description=&team_discoverability=&team_domain=&team_name="

headers = {
    'token': "",
    'content-type': "application/x-www-form-urlencoded"
}

conn.request("POST", "/baseUrl/admin.teams.create", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/admin.teams.create"

payload = {
    "team_description": "",
    "team_discoverability": "",
    "team_domain": "",
    "team_name": ""
}
headers = {
    "token": "",
    "content-type": "application/x-www-form-urlencoded"
}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.teams.create"

payload <- "team_description=&team_discoverability=&team_domain=&team_name="

encode <- "form"

response <- VERB("POST", url, body = payload, add_headers('token' = ''), content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.teams.create")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["token"] = ''
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "team_description=&team_discoverability=&team_domain=&team_name="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :team_description => "",
  :team_discoverability => "",
  :team_domain => "",
  :team_name => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/admin.teams.create') do |req|
  req.headers['token'] = ''
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.teams.create";

    let payload = json!({
        "team_description": "",
        "team_discoverability": "",
        "team_domain": "",
        "team_name": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("token", "".parse().unwrap());
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http --form POST {{baseUrl}}/admin.teams.create \
  content-type:application/x-www-form-urlencoded \
  token:'' \
  team_description='' \
  team_discoverability='' \
  team_domain='' \
  team_name=''

wget --quiet \
  --method POST \
  --header 'token: ' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'team_description=&team_discoverability=&team_domain=&team_name=' \
  --output-document \
  - {{baseUrl}}/admin.teams.create

import Foundation

let headers = [
  "token": "",
  "content-type": "application/x-www-form-urlencoded"
]

let postData = NSMutableData(data: "team_description=".data(using: String.Encoding.utf8)!)
postData.append("&team_discoverability=".data(using: String.Encoding.utf8)!)
postData.append("&team_domain=".data(using: String.Encoding.utf8)!)
postData.append("&team_name=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.teams.create")! 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}}/admin.teams.list");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/admin.teams.list" {:headers {:token ""}})

require "http/client"

url = "{{baseUrl}}/admin.teams.list"
headers = HTTP::Headers{
  "token" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/admin.teams.list"),
    Headers =
    {
        { "token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.teams.list");
var request = new RestRequest("", Method.Get);
request.AddHeader("token", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/admin.teams.list"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("token", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/admin.teams.list HTTP/1.1
Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin.teams.list")
  .setHeader("token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.teams.list"))
    .header("token", "")
    .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}}/admin.teams.list")
  .get()
  .addHeader("token", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/admin.teams.list")
  .header("token", "")
  .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}}/admin.teams.list');
xhr.setRequestHeader('token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin.teams.list',
  headers: {token: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/admin.teams.list';
const options = {method: 'GET', headers: {token: ''}};

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}}/admin.teams.list',
  method: 'GET',
  headers: {
    token: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin.teams.list")
  .get()
  .addHeader("token", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.teams.list',
  headers: {
    token: ''
  }
};

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}}/admin.teams.list',
  headers: {token: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/admin.teams.list');

req.headers({
  token: ''
});

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}}/admin.teams.list',
  headers: {token: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/admin.teams.list';
const options = {method: 'GET', headers: {token: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin.teams.list"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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}}/admin.teams.list" in
let headers = Header.add (Header.init ()) "token" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/admin.teams.list",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "token: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/admin.teams.list', [
  'headers' => [
    'token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin.teams.list');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'token' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/admin.teams.list');
$request->setRequestMethod('GET');
$request->setHeaders([
  'token' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.teams.list' -Method GET -Headers $headers

$headers=@{}
$headers.Add("token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.teams.list' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'token': "" }

conn.request("GET", "/baseUrl/admin.teams.list", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/admin.teams.list"

headers = {"token": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.teams.list"

response <- VERB("GET", url, add_headers('token' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.teams.list")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["token"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/admin.teams.list') do |req|
  req.headers['token'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.teams.list";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("token", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/admin.teams.list \
  token:''

wget --quiet \
  --method GET \
  --header 'token: ' \
  --output-document \
  - {{baseUrl}}/admin.teams.list

import Foundation

let headers = ["token": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.teams.list")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin.teams.admins.list?token=&team_id=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/admin.teams.admins.list" {:query-params {:token ""
                                                                                  :team_id ""}})

require "http/client"

url = "{{baseUrl}}/admin.teams.admins.list?token=&team_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}}/admin.teams.admins.list?token=&team_id="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.teams.admins.list?token=&team_id=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/admin.teams.admins.list?token=&team_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/admin.teams.admins.list?token=&team_id= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin.teams.admins.list?token=&team_id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.teams.admins.list?token=&team_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}}/admin.teams.admins.list?token=&team_id=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/admin.teams.admins.list?token=&team_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}}/admin.teams.admins.list?token=&team_id=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin.teams.admins.list',
  params: {token: '', team_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/admin.teams.admins.list?token=&team_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}}/admin.teams.admins.list?token=&team_id=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin.teams.admins.list?token=&team_id=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.teams.admins.list?token=&team_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}}/admin.teams.admins.list',
  qs: {token: '', team_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}}/admin.teams.admins.list');

req.query({
  token: '',
  team_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}}/admin.teams.admins.list',
  params: {token: '', team_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/admin.teams.admins.list?token=&team_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}}/admin.teams.admins.list?token=&team_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}}/admin.teams.admins.list?token=&team_id=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/admin.teams.admins.list?token=&team_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}}/admin.teams.admins.list?token=&team_id=');

echo $response->getBody();

setUrl('{{baseUrl}}/admin.teams.admins.list');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'token' => '',
  'team_id' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/admin.teams.admins.list');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'token' => '',
  'team_id' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.teams.admins.list?token=&team_id=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.teams.admins.list?token=&team_id=' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/admin.teams.admins.list?token=&team_id=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/admin.teams.admins.list"

querystring = {"token":"","team_id":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.teams.admins.list"

queryString <- list(
  token = "",
  team_id = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.teams.admins.list?token=&team_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/admin.teams.admins.list') do |req|
  req.params['token'] = ''
  req.params['team_id'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.teams.admins.list";

    let querystring = [
        ("token", ""),
        ("team_id", ""),
    ];

    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}}/admin.teams.admins.list?token=&team_id='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/admin.teams.admins.list?token=&team_id='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.teams.admins.list?token=&team_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}}/admin.teams.owners.list?token=&team_id=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/admin.teams.owners.list" {:query-params {:token ""
                                                                                  :team_id ""}})

require "http/client"

url = "{{baseUrl}}/admin.teams.owners.list?token=&team_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}}/admin.teams.owners.list?token=&team_id="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.teams.owners.list?token=&team_id=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/admin.teams.owners.list?token=&team_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/admin.teams.owners.list?token=&team_id= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin.teams.owners.list?token=&team_id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.teams.owners.list?token=&team_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}}/admin.teams.owners.list?token=&team_id=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/admin.teams.owners.list?token=&team_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}}/admin.teams.owners.list?token=&team_id=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin.teams.owners.list',
  params: {token: '', team_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/admin.teams.owners.list?token=&team_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}}/admin.teams.owners.list?token=&team_id=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin.teams.owners.list?token=&team_id=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.teams.owners.list?token=&team_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}}/admin.teams.owners.list',
  qs: {token: '', team_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}}/admin.teams.owners.list');

req.query({
  token: '',
  team_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}}/admin.teams.owners.list',
  params: {token: '', team_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/admin.teams.owners.list?token=&team_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}}/admin.teams.owners.list?token=&team_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}}/admin.teams.owners.list?token=&team_id=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/admin.teams.owners.list?token=&team_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}}/admin.teams.owners.list?token=&team_id=');

echo $response->getBody();

setUrl('{{baseUrl}}/admin.teams.owners.list');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'token' => '',
  'team_id' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/admin.teams.owners.list');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'token' => '',
  'team_id' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.teams.owners.list?token=&team_id=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.teams.owners.list?token=&team_id=' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/admin.teams.owners.list?token=&team_id=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/admin.teams.owners.list"

querystring = {"token":"","team_id":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.teams.owners.list"

queryString <- list(
  token = "",
  team_id = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.teams.owners.list?token=&team_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/admin.teams.owners.list') do |req|
  req.params['token'] = ''
  req.params['team_id'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.teams.owners.list";

    let querystring = [
        ("token", ""),
        ("team_id", ""),
    ];

    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}}/admin.teams.owners.list?token=&team_id='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/admin.teams.owners.list?token=&team_id='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.teams.owners.list?token=&team_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}}/admin.teams.settings.info?team_id=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/admin.teams.settings.info" {:headers {:token ""}
                                                                     :query-params {:team_id ""}})

require "http/client"

url = "{{baseUrl}}/admin.teams.settings.info?team_id="
headers = HTTP::Headers{
  "token" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/admin.teams.settings.info?team_id="),
    Headers =
    {
        { "token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.teams.settings.info?team_id=");
var request = new RestRequest("", Method.Get);
request.AddHeader("token", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/admin.teams.settings.info?team_id="

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("token", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/admin.teams.settings.info?team_id= HTTP/1.1
Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin.teams.settings.info?team_id=")
  .setHeader("token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.teams.settings.info?team_id="))
    .header("token", "")
    .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}}/admin.teams.settings.info?team_id=")
  .get()
  .addHeader("token", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/admin.teams.settings.info?team_id=")
  .header("token", "")
  .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}}/admin.teams.settings.info?team_id=');
xhr.setRequestHeader('token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin.teams.settings.info',
  params: {team_id: ''},
  headers: {token: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/admin.teams.settings.info?team_id=';
const options = {method: 'GET', headers: {token: ''}};

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}}/admin.teams.settings.info?team_id=',
  method: 'GET',
  headers: {
    token: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin.teams.settings.info?team_id=")
  .get()
  .addHeader("token", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.teams.settings.info?team_id=',
  headers: {
    token: ''
  }
};

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}}/admin.teams.settings.info',
  qs: {team_id: ''},
  headers: {token: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/admin.teams.settings.info');

req.query({
  team_id: ''
});

req.headers({
  token: ''
});

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}}/admin.teams.settings.info',
  params: {team_id: ''},
  headers: {token: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/admin.teams.settings.info?team_id=';
const options = {method: 'GET', headers: {token: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin.teams.settings.info?team_id="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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}}/admin.teams.settings.info?team_id=" in
let headers = Header.add (Header.init ()) "token" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/admin.teams.settings.info?team_id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "token: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/admin.teams.settings.info?team_id=', [
  'headers' => [
    'token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin.teams.settings.info');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'team_id' => ''
]);

$request->setHeaders([
  'token' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/admin.teams.settings.info');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'team_id' => ''
]));

$request->setHeaders([
  'token' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.teams.settings.info?team_id=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.teams.settings.info?team_id=' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'token': "" }

conn.request("GET", "/baseUrl/admin.teams.settings.info?team_id=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/admin.teams.settings.info"

querystring = {"team_id":""}

headers = {"token": ""}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.teams.settings.info"

queryString <- list(team_id = "")

response <- VERB("GET", url, query = queryString, add_headers('token' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.teams.settings.info?team_id=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["token"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/admin.teams.settings.info') do |req|
  req.headers['token'] = ''
  req.params['team_id'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.teams.settings.info";

    let querystring = [
        ("team_id", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("token", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET '{{baseUrl}}/admin.teams.settings.info?team_id=' \
  token:''

wget --quiet \
  --method GET \
  --header 'token: ' \
  --output-document \
  - '{{baseUrl}}/admin.teams.settings.info?team_id='

import Foundation

let headers = ["token": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.teams.settings.info?team_id=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin.teams.settings.setDefaultChannels");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "channel_ids=&team_id=&token=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/admin.teams.settings.setDefaultChannels" {:form-params {:channel_ids ""
                                                                                                  :team_id ""
                                                                                                  :token ""}})

require "http/client"

url = "{{baseUrl}}/admin.teams.settings.setDefaultChannels"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "channel_ids=&team_id=&token="

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}}/admin.teams.settings.setDefaultChannels"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "channel_ids", "" },
        { "team_id", "" },
        { "token", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.teams.settings.setDefaultChannels");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "channel_ids=&team_id=&token=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/admin.teams.settings.setDefaultChannels"

	payload := strings.NewReader("channel_ids=&team_id=&token=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/admin.teams.settings.setDefaultChannels HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 28

channel_ids=&team_id=&token=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin.teams.settings.setDefaultChannels")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("channel_ids=&team_id=&token=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.teams.settings.setDefaultChannels"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("channel_ids=&team_id=&token="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "channel_ids=&team_id=&token=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin.teams.settings.setDefaultChannels")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/admin.teams.settings.setDefaultChannels")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("channel_ids=&team_id=&token=")
  .asString();

const data = 'channel_ids=&team_id=&token=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/admin.teams.settings.setDefaultChannels');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('channel_ids', '');
encodedParams.set('team_id', '');
encodedParams.set('token', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.teams.settings.setDefaultChannels',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/admin.teams.settings.setDefaultChannels';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({channel_ids: '', team_id: '', token: ''})
};

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}}/admin.teams.settings.setDefaultChannels',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    channel_ids: '',
    team_id: '',
    token: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "channel_ids=&team_id=&token=")
val request = Request.Builder()
  .url("{{baseUrl}}/admin.teams.settings.setDefaultChannels")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.teams.settings.setDefaultChannels',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({channel_ids: '', team_id: '', token: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.teams.settings.setDefaultChannels',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {channel_ids: '', team_id: '', token: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/admin.teams.settings.setDefaultChannels');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  channel_ids: '',
  team_id: '',
  token: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('channel_ids', '');
encodedParams.set('team_id', '');
encodedParams.set('token', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.teams.settings.setDefaultChannels',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('channel_ids', '');
encodedParams.set('team_id', '');
encodedParams.set('token', '');

const url = '{{baseUrl}}/admin.teams.settings.setDefaultChannels';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"channel_ids=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&team_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&token=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin.teams.settings.setDefaultChannels"]
                                                       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}}/admin.teams.settings.setDefaultChannels" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "channel_ids=&team_id=&token=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/admin.teams.settings.setDefaultChannels",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "channel_ids=&team_id=&token=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/admin.teams.settings.setDefaultChannels', [
  'form_params' => [
    'channel_ids' => '',
    'team_id' => '',
    'token' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin.teams.settings.setDefaultChannels');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'channel_ids' => '',
  'team_id' => '',
  'token' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'channel_ids' => '',
  'team_id' => '',
  'token' => ''
]));

$request->setRequestUrl('{{baseUrl}}/admin.teams.settings.setDefaultChannels');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.teams.settings.setDefaultChannels' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'channel_ids=&team_id=&token='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.teams.settings.setDefaultChannels' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'channel_ids=&team_id=&token='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "channel_ids=&team_id=&token="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/admin.teams.settings.setDefaultChannels", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/admin.teams.settings.setDefaultChannels"

payload = {
    "channel_ids": "",
    "team_id": "",
    "token": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.teams.settings.setDefaultChannels"

payload <- "channel_ids=&team_id=&token="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.teams.settings.setDefaultChannels")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "channel_ids=&team_id=&token="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :channel_ids => "",
  :team_id => "",
  :token => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/admin.teams.settings.setDefaultChannels') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.teams.settings.setDefaultChannels";

    let payload = json!({
        "channel_ids": "",
        "team_id": "",
        "token": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http --form POST {{baseUrl}}/admin.teams.settings.setDefaultChannels \
  content-type:application/x-www-form-urlencoded \
  channel_ids='' \
  team_id='' \
  token=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'channel_ids=&team_id=&token=' \
  --output-document \
  - {{baseUrl}}/admin.teams.settings.setDefaultChannels

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "channel_ids=".data(using: String.Encoding.utf8)!)
postData.append("&team_id=".data(using: String.Encoding.utf8)!)
postData.append("&token=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.teams.settings.setDefaultChannels")! 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}}/admin.teams.settings.setDescription");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "token: ");
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "description=&team_id=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/admin.teams.settings.setDescription" {:headers {:token ""}
                                                                                :form-params {:description ""
                                                                                              :team_id ""}})

require "http/client"

url = "{{baseUrl}}/admin.teams.settings.setDescription"
headers = HTTP::Headers{
  "token" => ""
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "description=&team_id="

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}}/admin.teams.settings.setDescription"),
    Headers =
    {
        { "token", "" },
    },
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "description", "" },
        { "team_id", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.teams.settings.setDescription");
var request = new RestRequest("", Method.Post);
request.AddHeader("token", "");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "description=&team_id=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/admin.teams.settings.setDescription"

	payload := strings.NewReader("description=&team_id=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("token", "")
	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/admin.teams.settings.setDescription HTTP/1.1
Token: 
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 21

description=&team_id=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin.teams.settings.setDescription")
  .setHeader("token", "")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("description=&team_id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.teams.settings.setDescription"))
    .header("token", "")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("description=&team_id="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "description=&team_id=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin.teams.settings.setDescription")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/admin.teams.settings.setDescription")
  .header("token", "")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("description=&team_id=")
  .asString();

const data = 'description=&team_id=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/admin.teams.settings.setDescription');
xhr.setRequestHeader('token', '');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('description', '');
encodedParams.set('team_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.teams.settings.setDescription',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/admin.teams.settings.setDescription';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({description: '', team_id: ''})
};

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}}/admin.teams.settings.setDescription',
  method: 'POST',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    description: '',
    team_id: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "description=&team_id=")
val request = Request.Builder()
  .url("{{baseUrl}}/admin.teams.settings.setDescription")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.teams.settings.setDescription',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({description: '', team_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.teams.settings.setDescription',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  form: {description: '', team_id: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/admin.teams.settings.setDescription');

req.headers({
  token: '',
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  description: '',
  team_id: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('description', '');
encodedParams.set('team_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.teams.settings.setDescription',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('description', '');
encodedParams.set('team_id', '');

const url = '{{baseUrl}}/admin.teams.settings.setDescription';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"token": @"",
                           @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"description=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&team_id=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin.teams.settings.setDescription"]
                                                       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}}/admin.teams.settings.setDescription" in
let headers = Header.add_list (Header.init ()) [
  ("token", "");
  ("content-type", "application/x-www-form-urlencoded");
] in
let body = Cohttp_lwt_body.of_string "description=&team_id=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/admin.teams.settings.setDescription",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "description=&team_id=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "token: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/admin.teams.settings.setDescription', [
  'form_params' => [
    'description' => '',
    'team_id' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin.teams.settings.setDescription');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'description' => '',
  'team_id' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'description' => '',
  'team_id' => ''
]));

$request->setRequestUrl('{{baseUrl}}/admin.teams.settings.setDescription');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.teams.settings.setDescription' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'description=&team_id='

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.teams.settings.setDescription' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'description=&team_id='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "description=&team_id="

headers = {
    'token': "",
    'content-type': "application/x-www-form-urlencoded"
}

conn.request("POST", "/baseUrl/admin.teams.settings.setDescription", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/admin.teams.settings.setDescription"

payload = {
    "description": "",
    "team_id": ""
}
headers = {
    "token": "",
    "content-type": "application/x-www-form-urlencoded"
}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.teams.settings.setDescription"

payload <- "description=&team_id="

encode <- "form"

response <- VERB("POST", url, body = payload, add_headers('token' = ''), content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.teams.settings.setDescription")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["token"] = ''
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "description=&team_id="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :description => "",
  :team_id => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/admin.teams.settings.setDescription') do |req|
  req.headers['token'] = ''
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.teams.settings.setDescription";

    let payload = json!({
        "description": "",
        "team_id": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("token", "".parse().unwrap());
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http --form POST {{baseUrl}}/admin.teams.settings.setDescription \
  content-type:application/x-www-form-urlencoded \
  token:'' \
  description='' \
  team_id=''

wget --quiet \
  --method POST \
  --header 'token: ' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'description=&team_id=' \
  --output-document \
  - {{baseUrl}}/admin.teams.settings.setDescription

import Foundation

let headers = [
  "token": "",
  "content-type": "application/x-www-form-urlencoded"
]

let postData = NSMutableData(data: "description=".data(using: String.Encoding.utf8)!)
postData.append("&team_id=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.teams.settings.setDescription")! 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}}/admin.teams.settings.setDiscoverability");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "token: ");
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "discoverability=&team_id=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/admin.teams.settings.setDiscoverability" {:headers {:token ""}
                                                                                    :form-params {:discoverability ""
                                                                                                  :team_id ""}})

require "http/client"

url = "{{baseUrl}}/admin.teams.settings.setDiscoverability"
headers = HTTP::Headers{
  "token" => ""
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "discoverability=&team_id="

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}}/admin.teams.settings.setDiscoverability"),
    Headers =
    {
        { "token", "" },
    },
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "discoverability", "" },
        { "team_id", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.teams.settings.setDiscoverability");
var request = new RestRequest("", Method.Post);
request.AddHeader("token", "");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "discoverability=&team_id=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/admin.teams.settings.setDiscoverability"

	payload := strings.NewReader("discoverability=&team_id=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("token", "")
	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/admin.teams.settings.setDiscoverability HTTP/1.1
Token: 
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 25

discoverability=&team_id=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin.teams.settings.setDiscoverability")
  .setHeader("token", "")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("discoverability=&team_id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.teams.settings.setDiscoverability"))
    .header("token", "")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("discoverability=&team_id="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "discoverability=&team_id=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin.teams.settings.setDiscoverability")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/admin.teams.settings.setDiscoverability")
  .header("token", "")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("discoverability=&team_id=")
  .asString();

const data = 'discoverability=&team_id=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/admin.teams.settings.setDiscoverability');
xhr.setRequestHeader('token', '');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('discoverability', '');
encodedParams.set('team_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.teams.settings.setDiscoverability',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/admin.teams.settings.setDiscoverability';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({discoverability: '', team_id: ''})
};

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}}/admin.teams.settings.setDiscoverability',
  method: 'POST',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    discoverability: '',
    team_id: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "discoverability=&team_id=")
val request = Request.Builder()
  .url("{{baseUrl}}/admin.teams.settings.setDiscoverability")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.teams.settings.setDiscoverability',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({discoverability: '', team_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.teams.settings.setDiscoverability',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  form: {discoverability: '', team_id: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/admin.teams.settings.setDiscoverability');

req.headers({
  token: '',
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  discoverability: '',
  team_id: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('discoverability', '');
encodedParams.set('team_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.teams.settings.setDiscoverability',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('discoverability', '');
encodedParams.set('team_id', '');

const url = '{{baseUrl}}/admin.teams.settings.setDiscoverability';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"token": @"",
                           @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"discoverability=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&team_id=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin.teams.settings.setDiscoverability"]
                                                       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}}/admin.teams.settings.setDiscoverability" in
let headers = Header.add_list (Header.init ()) [
  ("token", "");
  ("content-type", "application/x-www-form-urlencoded");
] in
let body = Cohttp_lwt_body.of_string "discoverability=&team_id=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/admin.teams.settings.setDiscoverability",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "discoverability=&team_id=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "token: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/admin.teams.settings.setDiscoverability', [
  'form_params' => [
    'discoverability' => '',
    'team_id' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin.teams.settings.setDiscoverability');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'discoverability' => '',
  'team_id' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'discoverability' => '',
  'team_id' => ''
]));

$request->setRequestUrl('{{baseUrl}}/admin.teams.settings.setDiscoverability');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.teams.settings.setDiscoverability' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'discoverability=&team_id='

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.teams.settings.setDiscoverability' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'discoverability=&team_id='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "discoverability=&team_id="

headers = {
    'token': "",
    'content-type': "application/x-www-form-urlencoded"
}

conn.request("POST", "/baseUrl/admin.teams.settings.setDiscoverability", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/admin.teams.settings.setDiscoverability"

payload = {
    "discoverability": "",
    "team_id": ""
}
headers = {
    "token": "",
    "content-type": "application/x-www-form-urlencoded"
}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.teams.settings.setDiscoverability"

payload <- "discoverability=&team_id="

encode <- "form"

response <- VERB("POST", url, body = payload, add_headers('token' = ''), content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.teams.settings.setDiscoverability")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["token"] = ''
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "discoverability=&team_id="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :discoverability => "",
  :team_id => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/admin.teams.settings.setDiscoverability') do |req|
  req.headers['token'] = ''
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.teams.settings.setDiscoverability";

    let payload = json!({
        "discoverability": "",
        "team_id": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("token", "".parse().unwrap());
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http --form POST {{baseUrl}}/admin.teams.settings.setDiscoverability \
  content-type:application/x-www-form-urlencoded \
  token:'' \
  discoverability='' \
  team_id=''

wget --quiet \
  --method POST \
  --header 'token: ' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'discoverability=&team_id=' \
  --output-document \
  - {{baseUrl}}/admin.teams.settings.setDiscoverability

import Foundation

let headers = [
  "token": "",
  "content-type": "application/x-www-form-urlencoded"
]

let postData = NSMutableData(data: "discoverability=".data(using: String.Encoding.utf8)!)
postData.append("&team_id=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.teams.settings.setDiscoverability")! 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}}/admin.teams.settings.setIcon");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "image_url=&team_id=&token=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/admin.teams.settings.setIcon" {:form-params {:image_url ""
                                                                                       :team_id ""
                                                                                       :token ""}})

require "http/client"

url = "{{baseUrl}}/admin.teams.settings.setIcon"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "image_url=&team_id=&token="

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}}/admin.teams.settings.setIcon"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "image_url", "" },
        { "team_id", "" },
        { "token", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.teams.settings.setIcon");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "image_url=&team_id=&token=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/admin.teams.settings.setIcon"

	payload := strings.NewReader("image_url=&team_id=&token=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/admin.teams.settings.setIcon HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 26

image_url=&team_id=&token=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin.teams.settings.setIcon")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("image_url=&team_id=&token=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.teams.settings.setIcon"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("image_url=&team_id=&token="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "image_url=&team_id=&token=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin.teams.settings.setIcon")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/admin.teams.settings.setIcon")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("image_url=&team_id=&token=")
  .asString();

const data = 'image_url=&team_id=&token=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/admin.teams.settings.setIcon');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('image_url', '');
encodedParams.set('team_id', '');
encodedParams.set('token', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.teams.settings.setIcon',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/admin.teams.settings.setIcon';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({image_url: '', team_id: '', token: ''})
};

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}}/admin.teams.settings.setIcon',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    image_url: '',
    team_id: '',
    token: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "image_url=&team_id=&token=")
val request = Request.Builder()
  .url("{{baseUrl}}/admin.teams.settings.setIcon")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.teams.settings.setIcon',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({image_url: '', team_id: '', token: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.teams.settings.setIcon',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {image_url: '', team_id: '', token: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/admin.teams.settings.setIcon');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  image_url: '',
  team_id: '',
  token: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('image_url', '');
encodedParams.set('team_id', '');
encodedParams.set('token', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.teams.settings.setIcon',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('image_url', '');
encodedParams.set('team_id', '');
encodedParams.set('token', '');

const url = '{{baseUrl}}/admin.teams.settings.setIcon';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"image_url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&team_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&token=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin.teams.settings.setIcon"]
                                                       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}}/admin.teams.settings.setIcon" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "image_url=&team_id=&token=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/admin.teams.settings.setIcon",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "image_url=&team_id=&token=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/admin.teams.settings.setIcon', [
  'form_params' => [
    'image_url' => '',
    'team_id' => '',
    'token' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin.teams.settings.setIcon');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'image_url' => '',
  'team_id' => '',
  'token' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'image_url' => '',
  'team_id' => '',
  'token' => ''
]));

$request->setRequestUrl('{{baseUrl}}/admin.teams.settings.setIcon');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.teams.settings.setIcon' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'image_url=&team_id=&token='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.teams.settings.setIcon' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'image_url=&team_id=&token='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "image_url=&team_id=&token="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/admin.teams.settings.setIcon", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/admin.teams.settings.setIcon"

payload = {
    "image_url": "",
    "team_id": "",
    "token": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.teams.settings.setIcon"

payload <- "image_url=&team_id=&token="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.teams.settings.setIcon")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "image_url=&team_id=&token="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :image_url => "",
  :team_id => "",
  :token => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/admin.teams.settings.setIcon') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.teams.settings.setIcon";

    let payload = json!({
        "image_url": "",
        "team_id": "",
        "token": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http --form POST {{baseUrl}}/admin.teams.settings.setIcon \
  content-type:application/x-www-form-urlencoded \
  image_url='' \
  team_id='' \
  token=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'image_url=&team_id=&token=' \
  --output-document \
  - {{baseUrl}}/admin.teams.settings.setIcon

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "image_url=".data(using: String.Encoding.utf8)!)
postData.append("&team_id=".data(using: String.Encoding.utf8)!)
postData.append("&token=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.teams.settings.setIcon")! 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}}/admin.teams.settings.setName");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "token: ");
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "name=&team_id=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/admin.teams.settings.setName" {:headers {:token ""}
                                                                         :form-params {:name ""
                                                                                       :team_id ""}})

require "http/client"

url = "{{baseUrl}}/admin.teams.settings.setName"
headers = HTTP::Headers{
  "token" => ""
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "name=&team_id="

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}}/admin.teams.settings.setName"),
    Headers =
    {
        { "token", "" },
    },
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "name", "" },
        { "team_id", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.teams.settings.setName");
var request = new RestRequest("", Method.Post);
request.AddHeader("token", "");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "name=&team_id=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/admin.teams.settings.setName"

	payload := strings.NewReader("name=&team_id=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("token", "")
	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/admin.teams.settings.setName HTTP/1.1
Token: 
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 14

name=&team_id=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin.teams.settings.setName")
  .setHeader("token", "")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("name=&team_id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.teams.settings.setName"))
    .header("token", "")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("name=&team_id="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "name=&team_id=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin.teams.settings.setName")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/admin.teams.settings.setName")
  .header("token", "")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("name=&team_id=")
  .asString();

const data = 'name=&team_id=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/admin.teams.settings.setName');
xhr.setRequestHeader('token', '');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('name', '');
encodedParams.set('team_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.teams.settings.setName',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/admin.teams.settings.setName';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({name: '', team_id: ''})
};

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}}/admin.teams.settings.setName',
  method: 'POST',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    name: '',
    team_id: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "name=&team_id=")
val request = Request.Builder()
  .url("{{baseUrl}}/admin.teams.settings.setName")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.teams.settings.setName',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({name: '', team_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.teams.settings.setName',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  form: {name: '', team_id: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/admin.teams.settings.setName');

req.headers({
  token: '',
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  name: '',
  team_id: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('name', '');
encodedParams.set('team_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.teams.settings.setName',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('name', '');
encodedParams.set('team_id', '');

const url = '{{baseUrl}}/admin.teams.settings.setName';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"token": @"",
                           @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"name=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&team_id=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin.teams.settings.setName"]
                                                       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}}/admin.teams.settings.setName" in
let headers = Header.add_list (Header.init ()) [
  ("token", "");
  ("content-type", "application/x-www-form-urlencoded");
] in
let body = Cohttp_lwt_body.of_string "name=&team_id=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/admin.teams.settings.setName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "name=&team_id=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "token: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/admin.teams.settings.setName', [
  'form_params' => [
    'name' => '',
    'team_id' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin.teams.settings.setName');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'name' => '',
  'team_id' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'name' => '',
  'team_id' => ''
]));

$request->setRequestUrl('{{baseUrl}}/admin.teams.settings.setName');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.teams.settings.setName' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'name=&team_id='

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.teams.settings.setName' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'name=&team_id='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "name=&team_id="

headers = {
    'token': "",
    'content-type': "application/x-www-form-urlencoded"
}

conn.request("POST", "/baseUrl/admin.teams.settings.setName", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/admin.teams.settings.setName"

payload = {
    "name": "",
    "team_id": ""
}
headers = {
    "token": "",
    "content-type": "application/x-www-form-urlencoded"
}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.teams.settings.setName"

payload <- "name=&team_id="

encode <- "form"

response <- VERB("POST", url, body = payload, add_headers('token' = ''), content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.teams.settings.setName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["token"] = ''
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "name=&team_id="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :name => "",
  :team_id => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/admin.teams.settings.setName') do |req|
  req.headers['token'] = ''
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.teams.settings.setName";

    let payload = json!({
        "name": "",
        "team_id": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("token", "".parse().unwrap());
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http --form POST {{baseUrl}}/admin.teams.settings.setName \
  content-type:application/x-www-form-urlencoded \
  token:'' \
  name='' \
  team_id=''

wget --quiet \
  --method POST \
  --header 'token: ' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'name=&team_id=' \
  --output-document \
  - {{baseUrl}}/admin.teams.settings.setName

import Foundation

let headers = [
  "token": "",
  "content-type": "application/x-www-form-urlencoded"
]

let postData = NSMutableData(data: "name=".data(using: String.Encoding.utf8)!)
postData.append("&team_id=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.teams.settings.setName")! 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}}/admin.usergroups.addChannels");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "token: ");
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "channel_ids=&team_id=&usergroup_id=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/admin.usergroups.addChannels" {:headers {:token ""}
                                                                         :form-params {:channel_ids ""
                                                                                       :team_id ""
                                                                                       :usergroup_id ""}})

require "http/client"

url = "{{baseUrl}}/admin.usergroups.addChannels"
headers = HTTP::Headers{
  "token" => ""
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "channel_ids=&team_id=&usergroup_id="

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}}/admin.usergroups.addChannels"),
    Headers =
    {
        { "token", "" },
    },
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "channel_ids", "" },
        { "team_id", "" },
        { "usergroup_id", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.usergroups.addChannels");
var request = new RestRequest("", Method.Post);
request.AddHeader("token", "");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "channel_ids=&team_id=&usergroup_id=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/admin.usergroups.addChannels"

	payload := strings.NewReader("channel_ids=&team_id=&usergroup_id=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("token", "")
	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/admin.usergroups.addChannels HTTP/1.1
Token: 
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 35

channel_ids=&team_id=&usergroup_id=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin.usergroups.addChannels")
  .setHeader("token", "")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("channel_ids=&team_id=&usergroup_id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.usergroups.addChannels"))
    .header("token", "")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("channel_ids=&team_id=&usergroup_id="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "channel_ids=&team_id=&usergroup_id=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin.usergroups.addChannels")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/admin.usergroups.addChannels")
  .header("token", "")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("channel_ids=&team_id=&usergroup_id=")
  .asString();

const data = 'channel_ids=&team_id=&usergroup_id=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/admin.usergroups.addChannels');
xhr.setRequestHeader('token', '');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('channel_ids', '');
encodedParams.set('team_id', '');
encodedParams.set('usergroup_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.usergroups.addChannels',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/admin.usergroups.addChannels';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({channel_ids: '', team_id: '', usergroup_id: ''})
};

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}}/admin.usergroups.addChannels',
  method: 'POST',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    channel_ids: '',
    team_id: '',
    usergroup_id: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "channel_ids=&team_id=&usergroup_id=")
val request = Request.Builder()
  .url("{{baseUrl}}/admin.usergroups.addChannels")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.usergroups.addChannels',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({channel_ids: '', team_id: '', usergroup_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.usergroups.addChannels',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  form: {channel_ids: '', team_id: '', usergroup_id: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/admin.usergroups.addChannels');

req.headers({
  token: '',
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  channel_ids: '',
  team_id: '',
  usergroup_id: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('channel_ids', '');
encodedParams.set('team_id', '');
encodedParams.set('usergroup_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.usergroups.addChannels',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('channel_ids', '');
encodedParams.set('team_id', '');
encodedParams.set('usergroup_id', '');

const url = '{{baseUrl}}/admin.usergroups.addChannels';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"token": @"",
                           @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"channel_ids=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&team_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&usergroup_id=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin.usergroups.addChannels"]
                                                       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}}/admin.usergroups.addChannels" in
let headers = Header.add_list (Header.init ()) [
  ("token", "");
  ("content-type", "application/x-www-form-urlencoded");
] in
let body = Cohttp_lwt_body.of_string "channel_ids=&team_id=&usergroup_id=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/admin.usergroups.addChannels",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "channel_ids=&team_id=&usergroup_id=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "token: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/admin.usergroups.addChannels', [
  'form_params' => [
    'channel_ids' => '',
    'team_id' => '',
    'usergroup_id' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin.usergroups.addChannels');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'channel_ids' => '',
  'team_id' => '',
  'usergroup_id' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'channel_ids' => '',
  'team_id' => '',
  'usergroup_id' => ''
]));

$request->setRequestUrl('{{baseUrl}}/admin.usergroups.addChannels');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.usergroups.addChannels' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'channel_ids=&team_id=&usergroup_id='

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.usergroups.addChannels' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'channel_ids=&team_id=&usergroup_id='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "channel_ids=&team_id=&usergroup_id="

headers = {
    'token': "",
    'content-type': "application/x-www-form-urlencoded"
}

conn.request("POST", "/baseUrl/admin.usergroups.addChannels", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/admin.usergroups.addChannels"

payload = {
    "channel_ids": "",
    "team_id": "",
    "usergroup_id": ""
}
headers = {
    "token": "",
    "content-type": "application/x-www-form-urlencoded"
}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.usergroups.addChannels"

payload <- "channel_ids=&team_id=&usergroup_id="

encode <- "form"

response <- VERB("POST", url, body = payload, add_headers('token' = ''), content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.usergroups.addChannels")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["token"] = ''
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "channel_ids=&team_id=&usergroup_id="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :channel_ids => "",
  :team_id => "",
  :usergroup_id => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/admin.usergroups.addChannels') do |req|
  req.headers['token'] = ''
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.usergroups.addChannels";

    let payload = json!({
        "channel_ids": "",
        "team_id": "",
        "usergroup_id": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("token", "".parse().unwrap());
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http --form POST {{baseUrl}}/admin.usergroups.addChannels \
  content-type:application/x-www-form-urlencoded \
  token:'' \
  channel_ids='' \
  team_id='' \
  usergroup_id=''

wget --quiet \
  --method POST \
  --header 'token: ' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'channel_ids=&team_id=&usergroup_id=' \
  --output-document \
  - {{baseUrl}}/admin.usergroups.addChannels

import Foundation

let headers = [
  "token": "",
  "content-type": "application/x-www-form-urlencoded"
]

let postData = NSMutableData(data: "channel_ids=".data(using: String.Encoding.utf8)!)
postData.append("&team_id=".data(using: String.Encoding.utf8)!)
postData.append("&usergroup_id=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.usergroups.addChannels")! 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}}/admin.usergroups.addTeams");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "token: ");
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "auto_provision=&team_ids=&usergroup_id=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/admin.usergroups.addTeams" {:headers {:token ""}
                                                                      :form-params {:auto_provision ""
                                                                                    :team_ids ""
                                                                                    :usergroup_id ""}})

require "http/client"

url = "{{baseUrl}}/admin.usergroups.addTeams"
headers = HTTP::Headers{
  "token" => ""
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "auto_provision=&team_ids=&usergroup_id="

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}}/admin.usergroups.addTeams"),
    Headers =
    {
        { "token", "" },
    },
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "auto_provision", "" },
        { "team_ids", "" },
        { "usergroup_id", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin.usergroups.addTeams");
var request = new RestRequest("", Method.Post);
request.AddHeader("token", "");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "auto_provision=&team_ids=&usergroup_id=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/admin.usergroups.addTeams"

	payload := strings.NewReader("auto_provision=&team_ids=&usergroup_id=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("token", "")
	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/admin.usergroups.addTeams HTTP/1.1
Token: 
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 39

auto_provision=&team_ids=&usergroup_id=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin.usergroups.addTeams")
  .setHeader("token", "")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("auto_provision=&team_ids=&usergroup_id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin.usergroups.addTeams"))
    .header("token", "")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("auto_provision=&team_ids=&usergroup_id="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "auto_provision=&team_ids=&usergroup_id=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin.usergroups.addTeams")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/admin.usergroups.addTeams")
  .header("token", "")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("auto_provision=&team_ids=&usergroup_id=")
  .asString();

const data = 'auto_provision=&team_ids=&usergroup_id=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/admin.usergroups.addTeams');
xhr.setRequestHeader('token', '');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('auto_provision', '');
encodedParams.set('team_ids', '');
encodedParams.set('usergroup_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.usergroups.addTeams',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/admin.usergroups.addTeams';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({auto_provision: '', team_ids: '', usergroup_id: ''})
};

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}}/admin.usergroups.addTeams',
  method: 'POST',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    auto_provision: '',
    team_ids: '',
    usergroup_id: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "auto_provision=&team_ids=&usergroup_id=")
val request = Request.Builder()
  .url("{{baseUrl}}/admin.usergroups.addTeams")
  .post(body)
  .addHeader("token", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin.usergroups.addTeams',
  headers: {
    token: '',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({auto_provision: '', team_ids: '', usergroup_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.usergroups.addTeams',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  form: {auto_provision: '', team_ids: '', usergroup_id: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/admin.usergroups.addTeams');

req.headers({
  token: '',
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  auto_provision: '',
  team_ids: '',
  usergroup_id: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('auto_provision', '');
encodedParams.set('team_ids', '');
encodedParams.set('usergroup_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin.usergroups.addTeams',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('auto_provision', '');
encodedParams.set('team_ids', '');
encodedParams.set('usergroup_id', '');

const url = '{{baseUrl}}/admin.usergroups.addTeams';
const options = {
  method: 'POST',
  headers: {token: '', 'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"token": @"",
                           @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"auto_provision=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&team_ids=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&usergroup_id=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin.usergroups.addTeams"]
                                                       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}}/admin.usergroups.addTeams" in
let headers = Header.add_list (Header.init ()) [
  ("token", "");
  ("content-type", "application/x-www-form-urlencoded");
] in
let body = Cohttp_lwt_body.of_string "auto_provision=&team_ids=&usergroup_id=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/admin.usergroups.addTeams",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "auto_provision=&team_ids=&usergroup_id=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "token: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/admin.usergroups.addTeams', [
  'form_params' => [
    'auto_provision' => '',
    'team_ids' => '',
    'usergroup_id' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin.usergroups.addTeams');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'auto_provision' => '',
  'team_ids' => '',
  'usergroup_id' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'auto_provision' => '',
  'team_ids' => '',
  'usergroup_id' => ''
]));

$request->setRequestUrl('{{baseUrl}}/admin.usergroups.addTeams');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'token' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin.usergroups.addTeams' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'auto_provision=&team_ids=&usergroup_id='

$headers=@{}
$headers.Add("token", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin.usergroups.addTeams' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'auto_provision=&team_ids=&usergroup_id='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "auto_provision=&team_ids=&usergroup_id="

headers = {
    'token': "",
    'content-type': "application/x-www-form-urlencoded"
}

conn.request("POST", "/baseUrl/admin.usergroups.addTeams", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/admin.usergroups.addTeams"

payload = {
    "auto_provision": "",
    "team_ids": "",
    "usergroup_id": ""
}
headers = {
    "token": "",
    "content-type": "application/x-www-form-urlencoded"
}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin.usergroups.addTeams"

payload <- "auto_provision=&team_ids=&usergroup_id="

encode <- "form"

response <- VERB("POST", url, body = payload, add_headers('token' = ''), content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin.usergroups.addTeams")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["token"] = ''
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "auto_provision=&team_ids=&usergroup_id="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :auto_provision => "",
  :team_ids => "",
  :usergroup_id => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/admin.usergroups.addTeams') do |req|
  req.headers['token'] = ''
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin.usergroups.addTeams";

    let payload = json!({
        "auto_provision": "",
        "team_ids": "",
        "usergroup_id": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("token", "".parse().unwrap());
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http --form POST {{baseUrl}}/admin.usergroups.addTeams \
  content-type:application/x-www-form-urlencoded \
  token:'' \
  auto_provision='' \
  team_ids='' \
  usergroup_id=''

wget --quiet \
  --method POST \
  --header 'token: ' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'auto_provision=&team_ids=&usergroup_id=' \
  --output-document \
  - {{baseUrl}}/admin.usergroups.addTeams

import Foundation

let headers = [
  "token": "",
  "content-type": "application/x-www-form-urlencoded"
]

let postData = NSMutableData(data: "auto_provision=".data(using: String.Encoding.utf8)!)
postData.append("&team_ids=".data(using: String.Encoding.utf8)!)
postData.append("&usergroup_id=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin.usergroups.addTeams")! 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()