CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/:realm/attack-detection/brute-force/users");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/:realm/attack-detection/brute-force/users")

require "http/client"

url = "{{baseUrl}}/:realm/attack-detection/brute-force/users"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/:realm/attack-detection/brute-force/users"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/attack-detection/brute-force/users");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/:realm/attack-detection/brute-force/users"

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

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

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

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

}

DELETE /baseUrl/:realm/attack-detection/brute-force/users HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/:realm/attack-detection/brute-force/users")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/attack-detection/brute-force/users"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/:realm/attack-detection/brute-force/users")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/:realm/attack-detection/brute-force/users")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/:realm/attack-detection/brute-force/users');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/:realm/attack-detection/brute-force/users'
};

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

const url = '{{baseUrl}}/:realm/attack-detection/brute-force/users';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/:realm/attack-detection/brute-force/users',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/attack-detection/brute-force/users")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/attack-detection/brute-force/users',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/:realm/attack-detection/brute-force/users'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/:realm/attack-detection/brute-force/users');

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/:realm/attack-detection/brute-force/users'
};

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

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

const url = '{{baseUrl}}/:realm/attack-detection/brute-force/users';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/:realm/attack-detection/brute-force/users"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/:realm/attack-detection/brute-force/users" in

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

 "{{baseUrl}}/:realm/attack-detection/brute-force/users",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/:realm/attack-detection/brute-force/users');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/attack-detection/brute-force/users');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/:realm/attack-detection/brute-force/users');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/attack-detection/brute-force/users' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/attack-detection/brute-force/users' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/:realm/attack-detection/brute-force/users")

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

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

import requests

url = "{{baseUrl}}/:realm/attack-detection/brute-force/users"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/attack-detection/brute-force/users"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/attack-detection/brute-force/users")

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

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

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

require 'faraday'

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

response = conn.delete('/baseUrl/:realm/attack-detection/brute-force/users') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/attack-detection/brute-force/users";

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/:realm/attack-detection/brute-force/users

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/:realm/attack-detection/brute-force/users

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/attack-detection/brute-force/users")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId")

require "http/client"

url = "{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId"

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

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

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

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

}

DELETE /baseUrl/:realm/attack-detection/brute-force/users/:userId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId'
};

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

const url = '{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/attack-detection/brute-force/users/:userId',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId');

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId'
};

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

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

const url = '{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId" in

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

 "{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/:realm/attack-detection/brute-force/users/:userId")

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

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

import requests

url = "{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId")

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

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

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

require 'faraday'

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

response = conn.delete('/baseUrl/:realm/attack-detection/brute-force/users/:userId') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId";

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/:realm/attack-detection/brute-force/users/:userId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/:realm/attack-detection/brute-force/users/:userId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId")

require "http/client"

url = "{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId"

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}}/:realm/attack-detection/brute-force/users/:userId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId"

	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/:realm/attack-detection/brute-force/users/:userId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId"))
    .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}}/:realm/attack-detection/brute-force/users/:userId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId")
  .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}}/:realm/attack-detection/brute-force/users/:userId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId'
};

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

const url = '{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId';
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}}/:realm/attack-detection/brute-force/users/:userId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/attack-detection/brute-force/users/:userId',
  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}}/:realm/attack-detection/brute-force/users/:userId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId');

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}}/:realm/attack-detection/brute-force/users/:userId'
};

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

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

const url = '{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId';
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}}/:realm/attack-detection/brute-force/users/:userId"]
                                                       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}}/:realm/attack-detection/brute-force/users/:userId" in

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

 "{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId",
  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}}/:realm/attack-detection/brute-force/users/:userId');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/:realm/attack-detection/brute-force/users/:userId")

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

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

import requests

url = "{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId")

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/:realm/attack-detection/brute-force/users/:userId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/:realm/attack-detection/brute-force/users/:userId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/:realm/attack-detection/brute-force/users/:userId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/attack-detection/brute-force/users/:userId")! 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}}/:realm/authentication/flows/:flowAlias/executions/execution");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/execution" {:content-type :json})

require "http/client"

url = "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/execution"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{}"

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}}/:realm/authentication/flows/:flowAlias/executions/execution"),
    Content = new StringContent("{}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/execution");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/execution"

	payload := strings.NewReader("{}")

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

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

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

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

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

}

POST /baseUrl/:realm/authentication/flows/:flowAlias/executions/execution HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 2

{}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/execution")
  .setHeader("content-type", "application/json")
  .setBody("{}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/execution"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/execution")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/execution")
  .header("content-type", "application/json")
  .body("{}")
  .asString();

const data = JSON.stringify({});

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

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

xhr.open('POST', '{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/execution');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/execution',
  headers: {'content-type': 'application/json'},
  data: {}
};

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

const url = '{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/execution';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '{}'};

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}}/:realm/authentication/flows/:flowAlias/executions/execution',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{}")
val request = Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/execution")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/authentication/flows/:flowAlias/executions/execution',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/execution',
  headers: {'content-type': 'application/json'},
  body: {},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/execution');

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

req.type('json');
req.send({});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/execution',
  headers: {'content-type': 'application/json'},
  data: {}
};

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

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

const url = '{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/execution';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '{}'};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{  };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/execution"]
                                                       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}}/:realm/authentication/flows/:flowAlias/executions/execution" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{}" in

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

 "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/execution",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/execution', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/execution');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  
]));

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

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

append(json_encode([
  
]));
$request->setRequestUrl('{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/execution');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/execution' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/execution' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

import http.client

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

payload = "{}"

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

conn.request("POST", "/baseUrl/:realm/authentication/flows/:flowAlias/executions/execution", payload, headers)

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

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

import requests

url = "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/execution"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/execution"

payload <- "{}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/execution")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{}"

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

require 'faraday'

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

response = conn.post('/baseUrl/:realm/authentication/flows/:flowAlias/executions/execution') do |req|
  req.body = "{}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/execution";

    let payload = json!({});

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

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

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

    dbg!(results);
}

echo '{}' |  \
  http POST {{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/execution \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - {{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/execution

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/execution")! 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}}/:realm/authentication/executions");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"authenticator\": \"\",\n  \"authenticatorConfig\": \"\",\n  \"authenticatorFlow\": false,\n  \"autheticatorFlow\": false,\n  \"flowId\": \"\",\n  \"id\": \"\",\n  \"parentFlow\": \"\",\n  \"priority\": 0,\n  \"requirement\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/:realm/authentication/executions" {:content-type :json
                                                                             :form-params {:authenticator ""
                                                                                           :authenticatorConfig ""
                                                                                           :authenticatorFlow false
                                                                                           :autheticatorFlow false
                                                                                           :flowId ""
                                                                                           :id ""
                                                                                           :parentFlow ""
                                                                                           :priority 0
                                                                                           :requirement ""}})

require "http/client"

url = "{{baseUrl}}/:realm/authentication/executions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"authenticator\": \"\",\n  \"authenticatorConfig\": \"\",\n  \"authenticatorFlow\": false,\n  \"autheticatorFlow\": false,\n  \"flowId\": \"\",\n  \"id\": \"\",\n  \"parentFlow\": \"\",\n  \"priority\": 0,\n  \"requirement\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/:realm/authentication/executions"),
    Content = new StringContent("{\n  \"authenticator\": \"\",\n  \"authenticatorConfig\": \"\",\n  \"authenticatorFlow\": false,\n  \"autheticatorFlow\": false,\n  \"flowId\": \"\",\n  \"id\": \"\",\n  \"parentFlow\": \"\",\n  \"priority\": 0,\n  \"requirement\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/authentication/executions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"authenticator\": \"\",\n  \"authenticatorConfig\": \"\",\n  \"authenticatorFlow\": false,\n  \"autheticatorFlow\": false,\n  \"flowId\": \"\",\n  \"id\": \"\",\n  \"parentFlow\": \"\",\n  \"priority\": 0,\n  \"requirement\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/:realm/authentication/executions"

	payload := strings.NewReader("{\n  \"authenticator\": \"\",\n  \"authenticatorConfig\": \"\",\n  \"authenticatorFlow\": false,\n  \"autheticatorFlow\": false,\n  \"flowId\": \"\",\n  \"id\": \"\",\n  \"parentFlow\": \"\",\n  \"priority\": 0,\n  \"requirement\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/:realm/authentication/executions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 199

{
  "authenticator": "",
  "authenticatorConfig": "",
  "authenticatorFlow": false,
  "autheticatorFlow": false,
  "flowId": "",
  "id": "",
  "parentFlow": "",
  "priority": 0,
  "requirement": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/:realm/authentication/executions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"authenticator\": \"\",\n  \"authenticatorConfig\": \"\",\n  \"authenticatorFlow\": false,\n  \"autheticatorFlow\": false,\n  \"flowId\": \"\",\n  \"id\": \"\",\n  \"parentFlow\": \"\",\n  \"priority\": 0,\n  \"requirement\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/authentication/executions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"authenticator\": \"\",\n  \"authenticatorConfig\": \"\",\n  \"authenticatorFlow\": false,\n  \"autheticatorFlow\": false,\n  \"flowId\": \"\",\n  \"id\": \"\",\n  \"parentFlow\": \"\",\n  \"priority\": 0,\n  \"requirement\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"authenticator\": \"\",\n  \"authenticatorConfig\": \"\",\n  \"authenticatorFlow\": false,\n  \"autheticatorFlow\": false,\n  \"flowId\": \"\",\n  \"id\": \"\",\n  \"parentFlow\": \"\",\n  \"priority\": 0,\n  \"requirement\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/executions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/:realm/authentication/executions")
  .header("content-type", "application/json")
  .body("{\n  \"authenticator\": \"\",\n  \"authenticatorConfig\": \"\",\n  \"authenticatorFlow\": false,\n  \"autheticatorFlow\": false,\n  \"flowId\": \"\",\n  \"id\": \"\",\n  \"parentFlow\": \"\",\n  \"priority\": 0,\n  \"requirement\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  authenticator: '',
  authenticatorConfig: '',
  authenticatorFlow: false,
  autheticatorFlow: false,
  flowId: '',
  id: '',
  parentFlow: '',
  priority: 0,
  requirement: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/:realm/authentication/executions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/authentication/executions',
  headers: {'content-type': 'application/json'},
  data: {
    authenticator: '',
    authenticatorConfig: '',
    authenticatorFlow: false,
    autheticatorFlow: false,
    flowId: '',
    id: '',
    parentFlow: '',
    priority: 0,
    requirement: ''
  }
};

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

const url = '{{baseUrl}}/:realm/authentication/executions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"authenticator":"","authenticatorConfig":"","authenticatorFlow":false,"autheticatorFlow":false,"flowId":"","id":"","parentFlow":"","priority":0,"requirement":""}'
};

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}}/:realm/authentication/executions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "authenticator": "",\n  "authenticatorConfig": "",\n  "authenticatorFlow": false,\n  "autheticatorFlow": false,\n  "flowId": "",\n  "id": "",\n  "parentFlow": "",\n  "priority": 0,\n  "requirement": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"authenticator\": \"\",\n  \"authenticatorConfig\": \"\",\n  \"authenticatorFlow\": false,\n  \"autheticatorFlow\": false,\n  \"flowId\": \"\",\n  \"id\": \"\",\n  \"parentFlow\": \"\",\n  \"priority\": 0,\n  \"requirement\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/executions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/authentication/executions',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({
  authenticator: '',
  authenticatorConfig: '',
  authenticatorFlow: false,
  autheticatorFlow: false,
  flowId: '',
  id: '',
  parentFlow: '',
  priority: 0,
  requirement: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/authentication/executions',
  headers: {'content-type': 'application/json'},
  body: {
    authenticator: '',
    authenticatorConfig: '',
    authenticatorFlow: false,
    autheticatorFlow: false,
    flowId: '',
    id: '',
    parentFlow: '',
    priority: 0,
    requirement: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/:realm/authentication/executions');

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

req.type('json');
req.send({
  authenticator: '',
  authenticatorConfig: '',
  authenticatorFlow: false,
  autheticatorFlow: false,
  flowId: '',
  id: '',
  parentFlow: '',
  priority: 0,
  requirement: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/authentication/executions',
  headers: {'content-type': 'application/json'},
  data: {
    authenticator: '',
    authenticatorConfig: '',
    authenticatorFlow: false,
    autheticatorFlow: false,
    flowId: '',
    id: '',
    parentFlow: '',
    priority: 0,
    requirement: ''
  }
};

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

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

const url = '{{baseUrl}}/:realm/authentication/executions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"authenticator":"","authenticatorConfig":"","authenticatorFlow":false,"autheticatorFlow":false,"flowId":"","id":"","parentFlow":"","priority":0,"requirement":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"authenticator": @"",
                              @"authenticatorConfig": @"",
                              @"authenticatorFlow": @NO,
                              @"autheticatorFlow": @NO,
                              @"flowId": @"",
                              @"id": @"",
                              @"parentFlow": @"",
                              @"priority": @0,
                              @"requirement": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/:realm/authentication/executions"]
                                                       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}}/:realm/authentication/executions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"authenticator\": \"\",\n  \"authenticatorConfig\": \"\",\n  \"authenticatorFlow\": false,\n  \"autheticatorFlow\": false,\n  \"flowId\": \"\",\n  \"id\": \"\",\n  \"parentFlow\": \"\",\n  \"priority\": 0,\n  \"requirement\": \"\"\n}" in

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

 "{{baseUrl}}/:realm/authentication/executions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'authenticator' => '',
    'authenticatorConfig' => '',
    'authenticatorFlow' => null,
    'autheticatorFlow' => null,
    'flowId' => '',
    'id' => '',
    'parentFlow' => '',
    'priority' => 0,
    'requirement' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/:realm/authentication/executions', [
  'body' => '{
  "authenticator": "",
  "authenticatorConfig": "",
  "authenticatorFlow": false,
  "autheticatorFlow": false,
  "flowId": "",
  "id": "",
  "parentFlow": "",
  "priority": 0,
  "requirement": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/authentication/executions');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'authenticator' => '',
  'authenticatorConfig' => '',
  'authenticatorFlow' => null,
  'autheticatorFlow' => null,
  'flowId' => '',
  'id' => '',
  'parentFlow' => '',
  'priority' => 0,
  'requirement' => ''
]));

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

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

append(json_encode([
  'authenticator' => '',
  'authenticatorConfig' => '',
  'authenticatorFlow' => null,
  'autheticatorFlow' => null,
  'flowId' => '',
  'id' => '',
  'parentFlow' => '',
  'priority' => 0,
  'requirement' => ''
]));
$request->setRequestUrl('{{baseUrl}}/:realm/authentication/executions');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/authentication/executions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "authenticator": "",
  "authenticatorConfig": "",
  "authenticatorFlow": false,
  "autheticatorFlow": false,
  "flowId": "",
  "id": "",
  "parentFlow": "",
  "priority": 0,
  "requirement": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/authentication/executions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "authenticator": "",
  "authenticatorConfig": "",
  "authenticatorFlow": false,
  "autheticatorFlow": false,
  "flowId": "",
  "id": "",
  "parentFlow": "",
  "priority": 0,
  "requirement": ""
}'

import http.client

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

payload = "{\n  \"authenticator\": \"\",\n  \"authenticatorConfig\": \"\",\n  \"authenticatorFlow\": false,\n  \"autheticatorFlow\": false,\n  \"flowId\": \"\",\n  \"id\": \"\",\n  \"parentFlow\": \"\",\n  \"priority\": 0,\n  \"requirement\": \"\"\n}"

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

conn.request("POST", "/baseUrl/:realm/authentication/executions", payload, headers)

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

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

import requests

url = "{{baseUrl}}/:realm/authentication/executions"

payload = {
    "authenticator": "",
    "authenticatorConfig": "",
    "authenticatorFlow": False,
    "autheticatorFlow": False,
    "flowId": "",
    "id": "",
    "parentFlow": "",
    "priority": 0,
    "requirement": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/authentication/executions"

payload <- "{\n  \"authenticator\": \"\",\n  \"authenticatorConfig\": \"\",\n  \"authenticatorFlow\": false,\n  \"autheticatorFlow\": false,\n  \"flowId\": \"\",\n  \"id\": \"\",\n  \"parentFlow\": \"\",\n  \"priority\": 0,\n  \"requirement\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/authentication/executions")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"authenticator\": \"\",\n  \"authenticatorConfig\": \"\",\n  \"authenticatorFlow\": false,\n  \"autheticatorFlow\": false,\n  \"flowId\": \"\",\n  \"id\": \"\",\n  \"parentFlow\": \"\",\n  \"priority\": 0,\n  \"requirement\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/:realm/authentication/executions') do |req|
  req.body = "{\n  \"authenticator\": \"\",\n  \"authenticatorConfig\": \"\",\n  \"authenticatorFlow\": false,\n  \"autheticatorFlow\": false,\n  \"flowId\": \"\",\n  \"id\": \"\",\n  \"parentFlow\": \"\",\n  \"priority\": 0,\n  \"requirement\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/authentication/executions";

    let payload = json!({
        "authenticator": "",
        "authenticatorConfig": "",
        "authenticatorFlow": false,
        "autheticatorFlow": false,
        "flowId": "",
        "id": "",
        "parentFlow": "",
        "priority": 0,
        "requirement": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "authenticator": "",
  "authenticatorConfig": "",
  "authenticatorFlow": false,
  "autheticatorFlow": false,
  "flowId": "",
  "id": "",
  "parentFlow": "",
  "priority": 0,
  "requirement": ""
}' |  \
  http POST {{baseUrl}}/:realm/authentication/executions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "authenticator": "",\n  "authenticatorConfig": "",\n  "authenticatorFlow": false,\n  "autheticatorFlow": false,\n  "flowId": "",\n  "id": "",\n  "parentFlow": "",\n  "priority": 0,\n  "requirement": ""\n}' \
  --output-document \
  - {{baseUrl}}/:realm/authentication/executions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "authenticator": "",
  "authenticatorConfig": "",
  "authenticatorFlow": false,
  "autheticatorFlow": false,
  "flowId": "",
  "id": "",
  "parentFlow": "",
  "priority": 0,
  "requirement": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/authentication/executions")! 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}}/:realm/authentication/flows/:flowAlias/executions/flow");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/flow" {:content-type :json})

require "http/client"

url = "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/flow"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{}"

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}}/:realm/authentication/flows/:flowAlias/executions/flow"),
    Content = new StringContent("{}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/flow");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/flow"

	payload := strings.NewReader("{}")

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

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

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

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

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

}

POST /baseUrl/:realm/authentication/flows/:flowAlias/executions/flow HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 2

{}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/flow")
  .setHeader("content-type", "application/json")
  .setBody("{}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/flow"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/flow")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/flow")
  .header("content-type", "application/json")
  .body("{}")
  .asString();

const data = JSON.stringify({});

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

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

xhr.open('POST', '{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/flow');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/flow',
  headers: {'content-type': 'application/json'},
  data: {}
};

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

const url = '{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/flow';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '{}'};

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}}/:realm/authentication/flows/:flowAlias/executions/flow',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{}")
val request = Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/flow")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/authentication/flows/:flowAlias/executions/flow',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/flow',
  headers: {'content-type': 'application/json'},
  body: {},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/flow');

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

req.type('json');
req.send({});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/flow',
  headers: {'content-type': 'application/json'},
  data: {}
};

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

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

const url = '{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/flow';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '{}'};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{  };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/flow"]
                                                       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}}/:realm/authentication/flows/:flowAlias/executions/flow" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{}" in

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

 "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/flow",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/flow', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/flow');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  
]));

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

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

append(json_encode([
  
]));
$request->setRequestUrl('{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/flow');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/flow' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/flow' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

import http.client

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

payload = "{}"

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

conn.request("POST", "/baseUrl/:realm/authentication/flows/:flowAlias/executions/flow", payload, headers)

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

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

import requests

url = "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/flow"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/flow"

payload <- "{}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/flow")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{}"

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

require 'faraday'

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

response = conn.post('/baseUrl/:realm/authentication/flows/:flowAlias/executions/flow') do |req|
  req.body = "{}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/flow";

    let payload = json!({});

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

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

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

    dbg!(results);
}

echo '{}' |  \
  http POST {{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/flow \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - {{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/flow

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions/flow")! 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}}/:realm/authentication/flows/:flowAlias/copy");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/:realm/authentication/flows/:flowAlias/copy" {:content-type :json})

require "http/client"

url = "{{baseUrl}}/:realm/authentication/flows/:flowAlias/copy"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{}"

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}}/:realm/authentication/flows/:flowAlias/copy"),
    Content = new StringContent("{}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/authentication/flows/:flowAlias/copy");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/:realm/authentication/flows/:flowAlias/copy"

	payload := strings.NewReader("{}")

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

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

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

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

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

}

POST /baseUrl/:realm/authentication/flows/:flowAlias/copy HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 2

{}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/:realm/authentication/flows/:flowAlias/copy")
  .setHeader("content-type", "application/json")
  .setBody("{}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/authentication/flows/:flowAlias/copy"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/flows/:flowAlias/copy")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/:realm/authentication/flows/:flowAlias/copy")
  .header("content-type", "application/json")
  .body("{}")
  .asString();

const data = JSON.stringify({});

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

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

xhr.open('POST', '{{baseUrl}}/:realm/authentication/flows/:flowAlias/copy');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/authentication/flows/:flowAlias/copy',
  headers: {'content-type': 'application/json'},
  data: {}
};

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

const url = '{{baseUrl}}/:realm/authentication/flows/:flowAlias/copy';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '{}'};

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}}/:realm/authentication/flows/:flowAlias/copy',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{}")
val request = Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/flows/:flowAlias/copy")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/authentication/flows/:flowAlias/copy',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/authentication/flows/:flowAlias/copy',
  headers: {'content-type': 'application/json'},
  body: {},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/:realm/authentication/flows/:flowAlias/copy');

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

req.type('json');
req.send({});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/authentication/flows/:flowAlias/copy',
  headers: {'content-type': 'application/json'},
  data: {}
};

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

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

const url = '{{baseUrl}}/:realm/authentication/flows/:flowAlias/copy';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '{}'};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{  };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/:realm/authentication/flows/:flowAlias/copy"]
                                                       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}}/:realm/authentication/flows/:flowAlias/copy" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{}" in

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

 "{{baseUrl}}/:realm/authentication/flows/:flowAlias/copy",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/:realm/authentication/flows/:flowAlias/copy', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/authentication/flows/:flowAlias/copy');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  
]));

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

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

append(json_encode([
  
]));
$request->setRequestUrl('{{baseUrl}}/:realm/authentication/flows/:flowAlias/copy');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/authentication/flows/:flowAlias/copy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/authentication/flows/:flowAlias/copy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

import http.client

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

payload = "{}"

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

conn.request("POST", "/baseUrl/:realm/authentication/flows/:flowAlias/copy", payload, headers)

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

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

import requests

url = "{{baseUrl}}/:realm/authentication/flows/:flowAlias/copy"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/authentication/flows/:flowAlias/copy"

payload <- "{}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/authentication/flows/:flowAlias/copy")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{}"

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

require 'faraday'

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

response = conn.post('/baseUrl/:realm/authentication/flows/:flowAlias/copy') do |req|
  req.body = "{}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/authentication/flows/:flowAlias/copy";

    let payload = json!({});

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

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

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

    dbg!(results);
}

echo '{}' |  \
  http POST {{baseUrl}}/:realm/authentication/flows/:flowAlias/copy \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - {{baseUrl}}/:realm/authentication/flows/:flowAlias/copy

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/authentication/flows/:flowAlias/copy")! 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}}/:realm/authentication/flows");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"alias\": \"\",\n  \"authenticationExecutions\": [\n    {\n      \"authenticator\": \"\",\n      \"authenticatorConfig\": \"\",\n      \"authenticatorFlow\": false,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"priority\": 0,\n      \"requirement\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ],\n  \"builtIn\": false,\n  \"description\": \"\",\n  \"id\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/:realm/authentication/flows" {:content-type :json
                                                                        :form-params {:alias ""
                                                                                      :authenticationExecutions [{:authenticator ""
                                                                                                                  :authenticatorConfig ""
                                                                                                                  :authenticatorFlow false
                                                                                                                  :autheticatorFlow false
                                                                                                                  :flowAlias ""
                                                                                                                  :priority 0
                                                                                                                  :requirement ""
                                                                                                                  :userSetupAllowed false}]
                                                                                      :builtIn false
                                                                                      :description ""
                                                                                      :id ""
                                                                                      :providerId ""
                                                                                      :topLevel false}})

require "http/client"

url = "{{baseUrl}}/:realm/authentication/flows"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"alias\": \"\",\n  \"authenticationExecutions\": [\n    {\n      \"authenticator\": \"\",\n      \"authenticatorConfig\": \"\",\n      \"authenticatorFlow\": false,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"priority\": 0,\n      \"requirement\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ],\n  \"builtIn\": false,\n  \"description\": \"\",\n  \"id\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/:realm/authentication/flows"),
    Content = new StringContent("{\n  \"alias\": \"\",\n  \"authenticationExecutions\": [\n    {\n      \"authenticator\": \"\",\n      \"authenticatorConfig\": \"\",\n      \"authenticatorFlow\": false,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"priority\": 0,\n      \"requirement\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ],\n  \"builtIn\": false,\n  \"description\": \"\",\n  \"id\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/authentication/flows");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"alias\": \"\",\n  \"authenticationExecutions\": [\n    {\n      \"authenticator\": \"\",\n      \"authenticatorConfig\": \"\",\n      \"authenticatorFlow\": false,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"priority\": 0,\n      \"requirement\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ],\n  \"builtIn\": false,\n  \"description\": \"\",\n  \"id\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/:realm/authentication/flows"

	payload := strings.NewReader("{\n  \"alias\": \"\",\n  \"authenticationExecutions\": [\n    {\n      \"authenticator\": \"\",\n      \"authenticatorConfig\": \"\",\n      \"authenticatorFlow\": false,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"priority\": 0,\n      \"requirement\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ],\n  \"builtIn\": false,\n  \"description\": \"\",\n  \"id\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false\n}")

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

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

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

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

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

}

POST /baseUrl/:realm/authentication/flows HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 388

{
  "alias": "",
  "authenticationExecutions": [
    {
      "authenticator": "",
      "authenticatorConfig": "",
      "authenticatorFlow": false,
      "autheticatorFlow": false,
      "flowAlias": "",
      "priority": 0,
      "requirement": "",
      "userSetupAllowed": false
    }
  ],
  "builtIn": false,
  "description": "",
  "id": "",
  "providerId": "",
  "topLevel": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/:realm/authentication/flows")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"alias\": \"\",\n  \"authenticationExecutions\": [\n    {\n      \"authenticator\": \"\",\n      \"authenticatorConfig\": \"\",\n      \"authenticatorFlow\": false,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"priority\": 0,\n      \"requirement\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ],\n  \"builtIn\": false,\n  \"description\": \"\",\n  \"id\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/authentication/flows"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"alias\": \"\",\n  \"authenticationExecutions\": [\n    {\n      \"authenticator\": \"\",\n      \"authenticatorConfig\": \"\",\n      \"authenticatorFlow\": false,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"priority\": 0,\n      \"requirement\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ],\n  \"builtIn\": false,\n  \"description\": \"\",\n  \"id\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"alias\": \"\",\n  \"authenticationExecutions\": [\n    {\n      \"authenticator\": \"\",\n      \"authenticatorConfig\": \"\",\n      \"authenticatorFlow\": false,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"priority\": 0,\n      \"requirement\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ],\n  \"builtIn\": false,\n  \"description\": \"\",\n  \"id\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/flows")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/:realm/authentication/flows")
  .header("content-type", "application/json")
  .body("{\n  \"alias\": \"\",\n  \"authenticationExecutions\": [\n    {\n      \"authenticator\": \"\",\n      \"authenticatorConfig\": \"\",\n      \"authenticatorFlow\": false,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"priority\": 0,\n      \"requirement\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ],\n  \"builtIn\": false,\n  \"description\": \"\",\n  \"id\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false\n}")
  .asString();

const data = JSON.stringify({
  alias: '',
  authenticationExecutions: [
    {
      authenticator: '',
      authenticatorConfig: '',
      authenticatorFlow: false,
      autheticatorFlow: false,
      flowAlias: '',
      priority: 0,
      requirement: '',
      userSetupAllowed: false
    }
  ],
  builtIn: false,
  description: '',
  id: '',
  providerId: '',
  topLevel: false
});

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

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

xhr.open('POST', '{{baseUrl}}/:realm/authentication/flows');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/authentication/flows',
  headers: {'content-type': 'application/json'},
  data: {
    alias: '',
    authenticationExecutions: [
      {
        authenticator: '',
        authenticatorConfig: '',
        authenticatorFlow: false,
        autheticatorFlow: false,
        flowAlias: '',
        priority: 0,
        requirement: '',
        userSetupAllowed: false
      }
    ],
    builtIn: false,
    description: '',
    id: '',
    providerId: '',
    topLevel: false
  }
};

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

const url = '{{baseUrl}}/:realm/authentication/flows';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"alias":"","authenticationExecutions":[{"authenticator":"","authenticatorConfig":"","authenticatorFlow":false,"autheticatorFlow":false,"flowAlias":"","priority":0,"requirement":"","userSetupAllowed":false}],"builtIn":false,"description":"","id":"","providerId":"","topLevel":false}'
};

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}}/:realm/authentication/flows',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "alias": "",\n  "authenticationExecutions": [\n    {\n      "authenticator": "",\n      "authenticatorConfig": "",\n      "authenticatorFlow": false,\n      "autheticatorFlow": false,\n      "flowAlias": "",\n      "priority": 0,\n      "requirement": "",\n      "userSetupAllowed": false\n    }\n  ],\n  "builtIn": false,\n  "description": "",\n  "id": "",\n  "providerId": "",\n  "topLevel": false\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"alias\": \"\",\n  \"authenticationExecutions\": [\n    {\n      \"authenticator\": \"\",\n      \"authenticatorConfig\": \"\",\n      \"authenticatorFlow\": false,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"priority\": 0,\n      \"requirement\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ],\n  \"builtIn\": false,\n  \"description\": \"\",\n  \"id\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/flows")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/authentication/flows',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({
  alias: '',
  authenticationExecutions: [
    {
      authenticator: '',
      authenticatorConfig: '',
      authenticatorFlow: false,
      autheticatorFlow: false,
      flowAlias: '',
      priority: 0,
      requirement: '',
      userSetupAllowed: false
    }
  ],
  builtIn: false,
  description: '',
  id: '',
  providerId: '',
  topLevel: false
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/authentication/flows',
  headers: {'content-type': 'application/json'},
  body: {
    alias: '',
    authenticationExecutions: [
      {
        authenticator: '',
        authenticatorConfig: '',
        authenticatorFlow: false,
        autheticatorFlow: false,
        flowAlias: '',
        priority: 0,
        requirement: '',
        userSetupAllowed: false
      }
    ],
    builtIn: false,
    description: '',
    id: '',
    providerId: '',
    topLevel: false
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/:realm/authentication/flows');

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

req.type('json');
req.send({
  alias: '',
  authenticationExecutions: [
    {
      authenticator: '',
      authenticatorConfig: '',
      authenticatorFlow: false,
      autheticatorFlow: false,
      flowAlias: '',
      priority: 0,
      requirement: '',
      userSetupAllowed: false
    }
  ],
  builtIn: false,
  description: '',
  id: '',
  providerId: '',
  topLevel: false
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/authentication/flows',
  headers: {'content-type': 'application/json'},
  data: {
    alias: '',
    authenticationExecutions: [
      {
        authenticator: '',
        authenticatorConfig: '',
        authenticatorFlow: false,
        autheticatorFlow: false,
        flowAlias: '',
        priority: 0,
        requirement: '',
        userSetupAllowed: false
      }
    ],
    builtIn: false,
    description: '',
    id: '',
    providerId: '',
    topLevel: false
  }
};

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

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

const url = '{{baseUrl}}/:realm/authentication/flows';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"alias":"","authenticationExecutions":[{"authenticator":"","authenticatorConfig":"","authenticatorFlow":false,"autheticatorFlow":false,"flowAlias":"","priority":0,"requirement":"","userSetupAllowed":false}],"builtIn":false,"description":"","id":"","providerId":"","topLevel":false}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"alias": @"",
                              @"authenticationExecutions": @[ @{ @"authenticator": @"", @"authenticatorConfig": @"", @"authenticatorFlow": @NO, @"autheticatorFlow": @NO, @"flowAlias": @"", @"priority": @0, @"requirement": @"", @"userSetupAllowed": @NO } ],
                              @"builtIn": @NO,
                              @"description": @"",
                              @"id": @"",
                              @"providerId": @"",
                              @"topLevel": @NO };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/:realm/authentication/flows"]
                                                       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}}/:realm/authentication/flows" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"alias\": \"\",\n  \"authenticationExecutions\": [\n    {\n      \"authenticator\": \"\",\n      \"authenticatorConfig\": \"\",\n      \"authenticatorFlow\": false,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"priority\": 0,\n      \"requirement\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ],\n  \"builtIn\": false,\n  \"description\": \"\",\n  \"id\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false\n}" in

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

 "{{baseUrl}}/:realm/authentication/flows",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'alias' => '',
    'authenticationExecutions' => [
        [
                'authenticator' => '',
                'authenticatorConfig' => '',
                'authenticatorFlow' => null,
                'autheticatorFlow' => null,
                'flowAlias' => '',
                'priority' => 0,
                'requirement' => '',
                'userSetupAllowed' => null
        ]
    ],
    'builtIn' => null,
    'description' => '',
    'id' => '',
    'providerId' => '',
    'topLevel' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/:realm/authentication/flows', [
  'body' => '{
  "alias": "",
  "authenticationExecutions": [
    {
      "authenticator": "",
      "authenticatorConfig": "",
      "authenticatorFlow": false,
      "autheticatorFlow": false,
      "flowAlias": "",
      "priority": 0,
      "requirement": "",
      "userSetupAllowed": false
    }
  ],
  "builtIn": false,
  "description": "",
  "id": "",
  "providerId": "",
  "topLevel": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/authentication/flows');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'alias' => '',
  'authenticationExecutions' => [
    [
        'authenticator' => '',
        'authenticatorConfig' => '',
        'authenticatorFlow' => null,
        'autheticatorFlow' => null,
        'flowAlias' => '',
        'priority' => 0,
        'requirement' => '',
        'userSetupAllowed' => null
    ]
  ],
  'builtIn' => null,
  'description' => '',
  'id' => '',
  'providerId' => '',
  'topLevel' => null
]));

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

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

append(json_encode([
  'alias' => '',
  'authenticationExecutions' => [
    [
        'authenticator' => '',
        'authenticatorConfig' => '',
        'authenticatorFlow' => null,
        'autheticatorFlow' => null,
        'flowAlias' => '',
        'priority' => 0,
        'requirement' => '',
        'userSetupAllowed' => null
    ]
  ],
  'builtIn' => null,
  'description' => '',
  'id' => '',
  'providerId' => '',
  'topLevel' => null
]));
$request->setRequestUrl('{{baseUrl}}/:realm/authentication/flows');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/authentication/flows' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "alias": "",
  "authenticationExecutions": [
    {
      "authenticator": "",
      "authenticatorConfig": "",
      "authenticatorFlow": false,
      "autheticatorFlow": false,
      "flowAlias": "",
      "priority": 0,
      "requirement": "",
      "userSetupAllowed": false
    }
  ],
  "builtIn": false,
  "description": "",
  "id": "",
  "providerId": "",
  "topLevel": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/authentication/flows' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "alias": "",
  "authenticationExecutions": [
    {
      "authenticator": "",
      "authenticatorConfig": "",
      "authenticatorFlow": false,
      "autheticatorFlow": false,
      "flowAlias": "",
      "priority": 0,
      "requirement": "",
      "userSetupAllowed": false
    }
  ],
  "builtIn": false,
  "description": "",
  "id": "",
  "providerId": "",
  "topLevel": false
}'

import http.client

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

payload = "{\n  \"alias\": \"\",\n  \"authenticationExecutions\": [\n    {\n      \"authenticator\": \"\",\n      \"authenticatorConfig\": \"\",\n      \"authenticatorFlow\": false,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"priority\": 0,\n      \"requirement\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ],\n  \"builtIn\": false,\n  \"description\": \"\",\n  \"id\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false\n}"

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

conn.request("POST", "/baseUrl/:realm/authentication/flows", payload, headers)

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

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

import requests

url = "{{baseUrl}}/:realm/authentication/flows"

payload = {
    "alias": "",
    "authenticationExecutions": [
        {
            "authenticator": "",
            "authenticatorConfig": "",
            "authenticatorFlow": False,
            "autheticatorFlow": False,
            "flowAlias": "",
            "priority": 0,
            "requirement": "",
            "userSetupAllowed": False
        }
    ],
    "builtIn": False,
    "description": "",
    "id": "",
    "providerId": "",
    "topLevel": False
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/authentication/flows"

payload <- "{\n  \"alias\": \"\",\n  \"authenticationExecutions\": [\n    {\n      \"authenticator\": \"\",\n      \"authenticatorConfig\": \"\",\n      \"authenticatorFlow\": false,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"priority\": 0,\n      \"requirement\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ],\n  \"builtIn\": false,\n  \"description\": \"\",\n  \"id\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/authentication/flows")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"alias\": \"\",\n  \"authenticationExecutions\": [\n    {\n      \"authenticator\": \"\",\n      \"authenticatorConfig\": \"\",\n      \"authenticatorFlow\": false,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"priority\": 0,\n      \"requirement\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ],\n  \"builtIn\": false,\n  \"description\": \"\",\n  \"id\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/:realm/authentication/flows') do |req|
  req.body = "{\n  \"alias\": \"\",\n  \"authenticationExecutions\": [\n    {\n      \"authenticator\": \"\",\n      \"authenticatorConfig\": \"\",\n      \"authenticatorFlow\": false,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"priority\": 0,\n      \"requirement\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ],\n  \"builtIn\": false,\n  \"description\": \"\",\n  \"id\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/authentication/flows";

    let payload = json!({
        "alias": "",
        "authenticationExecutions": (
            json!({
                "authenticator": "",
                "authenticatorConfig": "",
                "authenticatorFlow": false,
                "autheticatorFlow": false,
                "flowAlias": "",
                "priority": 0,
                "requirement": "",
                "userSetupAllowed": false
            })
        ),
        "builtIn": false,
        "description": "",
        "id": "",
        "providerId": "",
        "topLevel": false
    });

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

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

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

    dbg!(results);
}

echo '{
  "alias": "",
  "authenticationExecutions": [
    {
      "authenticator": "",
      "authenticatorConfig": "",
      "authenticatorFlow": false,
      "autheticatorFlow": false,
      "flowAlias": "",
      "priority": 0,
      "requirement": "",
      "userSetupAllowed": false
    }
  ],
  "builtIn": false,
  "description": "",
  "id": "",
  "providerId": "",
  "topLevel": false
}' |  \
  http POST {{baseUrl}}/:realm/authentication/flows \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "alias": "",\n  "authenticationExecutions": [\n    {\n      "authenticator": "",\n      "authenticatorConfig": "",\n      "authenticatorFlow": false,\n      "autheticatorFlow": false,\n      "flowAlias": "",\n      "priority": 0,\n      "requirement": "",\n      "userSetupAllowed": false\n    }\n  ],\n  "builtIn": false,\n  "description": "",\n  "id": "",\n  "providerId": "",\n  "topLevel": false\n}' \
  --output-document \
  - {{baseUrl}}/:realm/authentication/flows

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "alias": "",
  "authenticationExecutions": [
    [
      "authenticator": "",
      "authenticatorConfig": "",
      "authenticatorFlow": false,
      "autheticatorFlow": false,
      "flowAlias": "",
      "priority": 0,
      "requirement": "",
      "userSetupAllowed": false
    ]
  ],
  "builtIn": false,
  "description": "",
  "id": "",
  "providerId": "",
  "topLevel": false
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/authentication/flows")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/:realm/authentication/flows/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/:realm/authentication/flows/:id")

require "http/client"

url = "{{baseUrl}}/:realm/authentication/flows/:id"

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

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

var client = new RestClient("{{baseUrl}}/:realm/authentication/flows/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/:realm/authentication/flows/:id"

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

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

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

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

}

DELETE /baseUrl/:realm/authentication/flows/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/:realm/authentication/flows/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/flows/:id")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/:realm/authentication/flows/:id")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/:realm/authentication/flows/:id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/:realm/authentication/flows/:id'
};

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

const url = '{{baseUrl}}/:realm/authentication/flows/:id';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/:realm/authentication/flows/:id',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/flows/:id")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/authentication/flows/:id',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/:realm/authentication/flows/:id'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/:realm/authentication/flows/:id');

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/:realm/authentication/flows/:id'
};

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

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

const url = '{{baseUrl}}/:realm/authentication/flows/:id';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/:realm/authentication/flows/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/:realm/authentication/flows/:id" in

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

 "{{baseUrl}}/:realm/authentication/flows/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/:realm/authentication/flows/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/authentication/flows/:id');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/:realm/authentication/flows/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/authentication/flows/:id' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/authentication/flows/:id' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/:realm/authentication/flows/:id")

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

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

import requests

url = "{{baseUrl}}/:realm/authentication/flows/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/authentication/flows/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/authentication/flows/:id")

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

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

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

require 'faraday'

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

response = conn.delete('/baseUrl/:realm/authentication/flows/:id') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/authentication/flows/:id";

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/:realm/authentication/flows/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/:realm/authentication/flows/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/authentication/flows/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/:realm/authentication/config/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/:realm/authentication/config/:id")

require "http/client"

url = "{{baseUrl}}/:realm/authentication/config/:id"

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

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

var client = new RestClient("{{baseUrl}}/:realm/authentication/config/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/:realm/authentication/config/:id"

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

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

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

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

}

DELETE /baseUrl/:realm/authentication/config/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/:realm/authentication/config/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/config/:id")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/:realm/authentication/config/:id")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/:realm/authentication/config/:id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/:realm/authentication/config/:id'
};

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

const url = '{{baseUrl}}/:realm/authentication/config/:id';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/:realm/authentication/config/:id',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/config/:id")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/authentication/config/:id',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/:realm/authentication/config/:id'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/:realm/authentication/config/:id');

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/:realm/authentication/config/:id'
};

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

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

const url = '{{baseUrl}}/:realm/authentication/config/:id';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/:realm/authentication/config/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/:realm/authentication/config/:id" in

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

 "{{baseUrl}}/:realm/authentication/config/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/:realm/authentication/config/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/authentication/config/:id');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/:realm/authentication/config/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/authentication/config/:id' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/authentication/config/:id' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/:realm/authentication/config/:id")

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

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

import requests

url = "{{baseUrl}}/:realm/authentication/config/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/authentication/config/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/authentication/config/:id")

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

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

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

require 'faraday'

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

response = conn.delete('/baseUrl/:realm/authentication/config/:id') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/authentication/config/:id";

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/:realm/authentication/config/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/:realm/authentication/config/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/authentication/config/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/:realm/authentication/executions/:executionId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/:realm/authentication/executions/:executionId")

require "http/client"

url = "{{baseUrl}}/:realm/authentication/executions/:executionId"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/:realm/authentication/executions/:executionId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/authentication/executions/:executionId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/:realm/authentication/executions/:executionId"

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

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

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

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

}

DELETE /baseUrl/:realm/authentication/executions/:executionId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/:realm/authentication/executions/:executionId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/authentication/executions/:executionId"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/executions/:executionId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/:realm/authentication/executions/:executionId")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/:realm/authentication/executions/:executionId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/:realm/authentication/executions/:executionId'
};

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

const url = '{{baseUrl}}/:realm/authentication/executions/:executionId';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/:realm/authentication/executions/:executionId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/executions/:executionId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/authentication/executions/:executionId',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/:realm/authentication/executions/:executionId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/:realm/authentication/executions/:executionId');

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/:realm/authentication/executions/:executionId'
};

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

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

const url = '{{baseUrl}}/:realm/authentication/executions/:executionId';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/:realm/authentication/executions/:executionId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/:realm/authentication/executions/:executionId" in

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

 "{{baseUrl}}/:realm/authentication/executions/:executionId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/:realm/authentication/executions/:executionId');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/authentication/executions/:executionId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/:realm/authentication/executions/:executionId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/authentication/executions/:executionId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/authentication/executions/:executionId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/:realm/authentication/executions/:executionId")

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

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

import requests

url = "{{baseUrl}}/:realm/authentication/executions/:executionId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/authentication/executions/:executionId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/authentication/executions/:executionId")

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

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

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

require 'faraday'

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

response = conn.delete('/baseUrl/:realm/authentication/executions/:executionId') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/authentication/executions/:executionId";

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/:realm/authentication/executions/:executionId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/:realm/authentication/executions/:executionId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/authentication/executions/:executionId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/:realm/authentication/required-actions/:alias");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/:realm/authentication/required-actions/:alias")

require "http/client"

url = "{{baseUrl}}/:realm/authentication/required-actions/:alias"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/:realm/authentication/required-actions/:alias"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/authentication/required-actions/:alias");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/:realm/authentication/required-actions/:alias"

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

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

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

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

}

DELETE /baseUrl/:realm/authentication/required-actions/:alias HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/:realm/authentication/required-actions/:alias")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/authentication/required-actions/:alias"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/required-actions/:alias")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/:realm/authentication/required-actions/:alias")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/:realm/authentication/required-actions/:alias');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/:realm/authentication/required-actions/:alias'
};

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

const url = '{{baseUrl}}/:realm/authentication/required-actions/:alias';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/:realm/authentication/required-actions/:alias',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/required-actions/:alias")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/authentication/required-actions/:alias',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/:realm/authentication/required-actions/:alias'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/:realm/authentication/required-actions/:alias');

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/:realm/authentication/required-actions/:alias'
};

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

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

const url = '{{baseUrl}}/:realm/authentication/required-actions/:alias';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/:realm/authentication/required-actions/:alias"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/:realm/authentication/required-actions/:alias" in

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

 "{{baseUrl}}/:realm/authentication/required-actions/:alias",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/:realm/authentication/required-actions/:alias');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/authentication/required-actions/:alias');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/:realm/authentication/required-actions/:alias');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/authentication/required-actions/:alias' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/authentication/required-actions/:alias' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/:realm/authentication/required-actions/:alias")

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

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

import requests

url = "{{baseUrl}}/:realm/authentication/required-actions/:alias"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/authentication/required-actions/:alias"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/authentication/required-actions/:alias")

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

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

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

require 'faraday'

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

response = conn.delete('/baseUrl/:realm/authentication/required-actions/:alias') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/authentication/required-actions/:alias";

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/:realm/authentication/required-actions/:alias

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/:realm/authentication/required-actions/:alias

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/authentication/required-actions/:alias")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/:realm/authentication/executions/:executionId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/:realm/authentication/executions/:executionId")

require "http/client"

url = "{{baseUrl}}/:realm/authentication/executions/:executionId"

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}}/:realm/authentication/executions/:executionId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/authentication/executions/:executionId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/:realm/authentication/executions/:executionId"

	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/:realm/authentication/executions/:executionId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/:realm/authentication/executions/:executionId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/authentication/executions/:executionId"))
    .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}}/:realm/authentication/executions/:executionId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/:realm/authentication/executions/:executionId")
  .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}}/:realm/authentication/executions/:executionId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/:realm/authentication/executions/:executionId'
};

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

const url = '{{baseUrl}}/:realm/authentication/executions/:executionId';
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}}/:realm/authentication/executions/:executionId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/executions/:executionId")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/authentication/executions/:executionId',
  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}}/:realm/authentication/executions/:executionId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/:realm/authentication/executions/:executionId');

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}}/:realm/authentication/executions/:executionId'
};

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

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

const url = '{{baseUrl}}/:realm/authentication/executions/:executionId';
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}}/:realm/authentication/executions/:executionId"]
                                                       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}}/:realm/authentication/executions/:executionId" in

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

 "{{baseUrl}}/:realm/authentication/executions/:executionId",
  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}}/:realm/authentication/executions/:executionId');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/authentication/executions/:executionId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/:realm/authentication/executions/:executionId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/authentication/executions/:executionId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/authentication/executions/:executionId' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/:realm/authentication/executions/:executionId")

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

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

import requests

url = "{{baseUrl}}/:realm/authentication/executions/:executionId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/authentication/executions/:executionId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/authentication/executions/:executionId")

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/:realm/authentication/executions/:executionId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/authentication/executions/:executionId";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/:realm/authentication/executions/:executionId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/:realm/authentication/executions/:executionId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/authentication/executions/:executionId")! 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}}/:realm/authentication/flows/:flowAlias/executions");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions")

require "http/client"

url = "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions"

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}}/:realm/authentication/flows/:flowAlias/executions"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions"

	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/:realm/authentication/flows/:flowAlias/executions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions"))
    .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}}/:realm/authentication/flows/:flowAlias/executions")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions")
  .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}}/:realm/authentication/flows/:flowAlias/executions');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions'
};

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

const url = '{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions';
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}}/:realm/authentication/flows/:flowAlias/executions',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/authentication/flows/:flowAlias/executions',
  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}}/:realm/authentication/flows/:flowAlias/executions'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions');

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}}/:realm/authentication/flows/:flowAlias/executions'
};

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

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

const url = '{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions';
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}}/:realm/authentication/flows/:flowAlias/executions"]
                                                       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}}/:realm/authentication/flows/:flowAlias/executions" in

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

 "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions",
  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}}/:realm/authentication/flows/:flowAlias/executions');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/:realm/authentication/flows/:flowAlias/executions")

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

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

import requests

url = "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions")

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/:realm/authentication/flows/:flowAlias/executions') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/:realm/authentication/flows/:flowAlias/executions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/:realm/authentication/flows/:flowAlias/executions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions")! 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}}/:realm/authentication/flows/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/:realm/authentication/flows/:id")

require "http/client"

url = "{{baseUrl}}/:realm/authentication/flows/: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}}/:realm/authentication/flows/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/authentication/flows/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/:realm/authentication/flows/: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/:realm/authentication/flows/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/:realm/authentication/flows/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/authentication/flows/: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}}/:realm/authentication/flows/:id")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/:realm/authentication/flows/: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}}/:realm/authentication/flows/:id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/:realm/authentication/flows/:id'
};

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

const url = '{{baseUrl}}/:realm/authentication/flows/: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}}/:realm/authentication/flows/:id',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/flows/:id")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/authentication/flows/: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}}/:realm/authentication/flows/: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}}/:realm/authentication/flows/: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}}/:realm/authentication/flows/:id'
};

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

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

const url = '{{baseUrl}}/:realm/authentication/flows/: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}}/:realm/authentication/flows/: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}}/:realm/authentication/flows/:id" in

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

 "{{baseUrl}}/:realm/authentication/flows/: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}}/:realm/authentication/flows/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/authentication/flows/:id');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/:realm/authentication/flows/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/authentication/flows/:id' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/authentication/flows/:id' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/:realm/authentication/flows/:id")

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

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

import requests

url = "{{baseUrl}}/:realm/authentication/flows/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/authentication/flows/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/authentication/flows/: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/:realm/authentication/flows/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/authentication/flows/:id";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/:realm/authentication/flows/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/:realm/authentication/flows/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/authentication/flows/: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}}/:realm/authentication/flows");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/:realm/authentication/flows")

require "http/client"

url = "{{baseUrl}}/:realm/authentication/flows"

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}}/:realm/authentication/flows"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/authentication/flows");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/:realm/authentication/flows"

	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/:realm/authentication/flows HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/:realm/authentication/flows")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/authentication/flows"))
    .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}}/:realm/authentication/flows")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/:realm/authentication/flows")
  .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}}/:realm/authentication/flows');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/:realm/authentication/flows'};

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

const url = '{{baseUrl}}/:realm/authentication/flows';
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}}/:realm/authentication/flows',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/flows")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/authentication/flows',
  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}}/:realm/authentication/flows'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/:realm/authentication/flows');

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}}/:realm/authentication/flows'};

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

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

const url = '{{baseUrl}}/:realm/authentication/flows';
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}}/:realm/authentication/flows"]
                                                       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}}/:realm/authentication/flows" in

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

 "{{baseUrl}}/:realm/authentication/flows",
  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}}/:realm/authentication/flows');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/authentication/flows');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/:realm/authentication/flows');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/authentication/flows' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/authentication/flows' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/:realm/authentication/flows")

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

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

import requests

url = "{{baseUrl}}/:realm/authentication/flows"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/authentication/flows"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/authentication/flows")

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/:realm/authentication/flows') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/authentication/flows";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/:realm/authentication/flows

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/:realm/authentication/flows

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/authentication/flows")! 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}}/:realm/authentication/config/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/:realm/authentication/config/:id")

require "http/client"

url = "{{baseUrl}}/:realm/authentication/config/: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}}/:realm/authentication/config/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/authentication/config/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/:realm/authentication/config/: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/:realm/authentication/config/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/:realm/authentication/config/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/authentication/config/: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}}/:realm/authentication/config/:id")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/:realm/authentication/config/: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}}/:realm/authentication/config/:id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/:realm/authentication/config/:id'
};

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

const url = '{{baseUrl}}/:realm/authentication/config/: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}}/:realm/authentication/config/:id',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/config/:id")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/authentication/config/: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}}/:realm/authentication/config/: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}}/:realm/authentication/config/: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}}/:realm/authentication/config/:id'
};

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

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

const url = '{{baseUrl}}/:realm/authentication/config/: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}}/:realm/authentication/config/: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}}/:realm/authentication/config/:id" in

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

 "{{baseUrl}}/:realm/authentication/config/: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}}/:realm/authentication/config/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/authentication/config/:id');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/:realm/authentication/config/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/authentication/config/:id' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/authentication/config/:id' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/:realm/authentication/config/:id")

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

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

import requests

url = "{{baseUrl}}/:realm/authentication/config/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/authentication/config/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/authentication/config/: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/:realm/authentication/config/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/authentication/config/:id";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/:realm/authentication/config/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/:realm/authentication/config/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/authentication/config/: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}}/:realm/authentication/authenticator-providers");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/:realm/authentication/authenticator-providers")

require "http/client"

url = "{{baseUrl}}/:realm/authentication/authenticator-providers"

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}}/:realm/authentication/authenticator-providers"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/authentication/authenticator-providers");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/:realm/authentication/authenticator-providers"

	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/:realm/authentication/authenticator-providers HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/:realm/authentication/authenticator-providers")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/authentication/authenticator-providers"))
    .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}}/:realm/authentication/authenticator-providers")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/:realm/authentication/authenticator-providers")
  .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}}/:realm/authentication/authenticator-providers');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/:realm/authentication/authenticator-providers'
};

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

const url = '{{baseUrl}}/:realm/authentication/authenticator-providers';
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}}/:realm/authentication/authenticator-providers',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/authenticator-providers")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/authentication/authenticator-providers',
  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}}/:realm/authentication/authenticator-providers'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/:realm/authentication/authenticator-providers');

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}}/:realm/authentication/authenticator-providers'
};

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

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

const url = '{{baseUrl}}/:realm/authentication/authenticator-providers';
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}}/:realm/authentication/authenticator-providers"]
                                                       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}}/:realm/authentication/authenticator-providers" in

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

 "{{baseUrl}}/:realm/authentication/authenticator-providers",
  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}}/:realm/authentication/authenticator-providers');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/authentication/authenticator-providers');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/:realm/authentication/authenticator-providers');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/authentication/authenticator-providers' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/authentication/authenticator-providers' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/:realm/authentication/authenticator-providers")

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

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

import requests

url = "{{baseUrl}}/:realm/authentication/authenticator-providers"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/authentication/authenticator-providers"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/authentication/authenticator-providers")

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/:realm/authentication/authenticator-providers') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/authentication/authenticator-providers";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/:realm/authentication/authenticator-providers

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/:realm/authentication/authenticator-providers

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/authentication/authenticator-providers")! 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}}/:realm/authentication/config-description/:providerId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/:realm/authentication/config-description/:providerId")

require "http/client"

url = "{{baseUrl}}/:realm/authentication/config-description/:providerId"

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}}/:realm/authentication/config-description/:providerId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/authentication/config-description/:providerId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/:realm/authentication/config-description/:providerId"

	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/:realm/authentication/config-description/:providerId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/:realm/authentication/config-description/:providerId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/authentication/config-description/:providerId"))
    .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}}/:realm/authentication/config-description/:providerId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/:realm/authentication/config-description/:providerId")
  .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}}/:realm/authentication/config-description/:providerId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/:realm/authentication/config-description/:providerId'
};

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

const url = '{{baseUrl}}/:realm/authentication/config-description/:providerId';
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}}/:realm/authentication/config-description/:providerId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/config-description/:providerId")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/authentication/config-description/:providerId',
  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}}/:realm/authentication/config-description/:providerId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/:realm/authentication/config-description/:providerId');

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}}/:realm/authentication/config-description/:providerId'
};

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

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

const url = '{{baseUrl}}/:realm/authentication/config-description/:providerId';
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}}/:realm/authentication/config-description/:providerId"]
                                                       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}}/:realm/authentication/config-description/:providerId" in

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

 "{{baseUrl}}/:realm/authentication/config-description/:providerId",
  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}}/:realm/authentication/config-description/:providerId');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/authentication/config-description/:providerId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/:realm/authentication/config-description/:providerId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/authentication/config-description/:providerId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/authentication/config-description/:providerId' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/:realm/authentication/config-description/:providerId")

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

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

import requests

url = "{{baseUrl}}/:realm/authentication/config-description/:providerId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/authentication/config-description/:providerId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/authentication/config-description/:providerId")

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/:realm/authentication/config-description/:providerId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/authentication/config-description/:providerId";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/:realm/authentication/config-description/:providerId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/:realm/authentication/config-description/:providerId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/authentication/config-description/:providerId")! 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}}/:realm/authentication/client-authenticator-providers");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/:realm/authentication/client-authenticator-providers")

require "http/client"

url = "{{baseUrl}}/:realm/authentication/client-authenticator-providers"

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}}/:realm/authentication/client-authenticator-providers"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/authentication/client-authenticator-providers");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/:realm/authentication/client-authenticator-providers"

	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/:realm/authentication/client-authenticator-providers HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/:realm/authentication/client-authenticator-providers")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/authentication/client-authenticator-providers"))
    .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}}/:realm/authentication/client-authenticator-providers")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/:realm/authentication/client-authenticator-providers")
  .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}}/:realm/authentication/client-authenticator-providers');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/:realm/authentication/client-authenticator-providers'
};

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

const url = '{{baseUrl}}/:realm/authentication/client-authenticator-providers';
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}}/:realm/authentication/client-authenticator-providers',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/client-authenticator-providers")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/authentication/client-authenticator-providers',
  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}}/:realm/authentication/client-authenticator-providers'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/:realm/authentication/client-authenticator-providers');

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}}/:realm/authentication/client-authenticator-providers'
};

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

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

const url = '{{baseUrl}}/:realm/authentication/client-authenticator-providers';
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}}/:realm/authentication/client-authenticator-providers"]
                                                       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}}/:realm/authentication/client-authenticator-providers" in

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

 "{{baseUrl}}/:realm/authentication/client-authenticator-providers",
  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}}/:realm/authentication/client-authenticator-providers');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/authentication/client-authenticator-providers');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/:realm/authentication/client-authenticator-providers');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/authentication/client-authenticator-providers' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/authentication/client-authenticator-providers' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/:realm/authentication/client-authenticator-providers")

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

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

import requests

url = "{{baseUrl}}/:realm/authentication/client-authenticator-providers"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/authentication/client-authenticator-providers"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/authentication/client-authenticator-providers")

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/:realm/authentication/client-authenticator-providers') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/authentication/client-authenticator-providers";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/:realm/authentication/client-authenticator-providers

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/:realm/authentication/client-authenticator-providers

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/authentication/client-authenticator-providers")! 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}}/:realm/authentication/per-client-config-description");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/:realm/authentication/per-client-config-description")

require "http/client"

url = "{{baseUrl}}/:realm/authentication/per-client-config-description"

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}}/:realm/authentication/per-client-config-description"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/authentication/per-client-config-description");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/:realm/authentication/per-client-config-description"

	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/:realm/authentication/per-client-config-description HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/:realm/authentication/per-client-config-description")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/authentication/per-client-config-description"))
    .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}}/:realm/authentication/per-client-config-description")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/:realm/authentication/per-client-config-description")
  .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}}/:realm/authentication/per-client-config-description');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/:realm/authentication/per-client-config-description'
};

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

const url = '{{baseUrl}}/:realm/authentication/per-client-config-description';
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}}/:realm/authentication/per-client-config-description',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/per-client-config-description")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/authentication/per-client-config-description',
  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}}/:realm/authentication/per-client-config-description'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/:realm/authentication/per-client-config-description');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/:realm/authentication/per-client-config-description'
};

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

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

const url = '{{baseUrl}}/:realm/authentication/per-client-config-description';
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}}/:realm/authentication/per-client-config-description"]
                                                       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}}/:realm/authentication/per-client-config-description" in

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

 "{{baseUrl}}/:realm/authentication/per-client-config-description",
  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}}/:realm/authentication/per-client-config-description');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/authentication/per-client-config-description');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/:realm/authentication/per-client-config-description');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/authentication/per-client-config-description' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/authentication/per-client-config-description' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/:realm/authentication/per-client-config-description")

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

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

import requests

url = "{{baseUrl}}/:realm/authentication/per-client-config-description"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/authentication/per-client-config-description"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/authentication/per-client-config-description")

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/:realm/authentication/per-client-config-description') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/authentication/per-client-config-description";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/:realm/authentication/per-client-config-description

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/:realm/authentication/per-client-config-description

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/authentication/per-client-config-description")! 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}}/:realm/authentication/form-action-providers");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/:realm/authentication/form-action-providers")

require "http/client"

url = "{{baseUrl}}/:realm/authentication/form-action-providers"

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}}/:realm/authentication/form-action-providers"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/authentication/form-action-providers");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/:realm/authentication/form-action-providers"

	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/:realm/authentication/form-action-providers HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/:realm/authentication/form-action-providers")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/authentication/form-action-providers"))
    .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}}/:realm/authentication/form-action-providers")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/:realm/authentication/form-action-providers")
  .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}}/:realm/authentication/form-action-providers');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/:realm/authentication/form-action-providers'
};

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

const url = '{{baseUrl}}/:realm/authentication/form-action-providers';
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}}/:realm/authentication/form-action-providers',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/form-action-providers")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/authentication/form-action-providers',
  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}}/:realm/authentication/form-action-providers'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/:realm/authentication/form-action-providers');

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}}/:realm/authentication/form-action-providers'
};

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

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

const url = '{{baseUrl}}/:realm/authentication/form-action-providers';
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}}/:realm/authentication/form-action-providers"]
                                                       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}}/:realm/authentication/form-action-providers" in

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

 "{{baseUrl}}/:realm/authentication/form-action-providers",
  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}}/:realm/authentication/form-action-providers');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/authentication/form-action-providers');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/:realm/authentication/form-action-providers');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/authentication/form-action-providers' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/authentication/form-action-providers' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/:realm/authentication/form-action-providers")

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

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

import requests

url = "{{baseUrl}}/:realm/authentication/form-action-providers"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/authentication/form-action-providers"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/authentication/form-action-providers")

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/:realm/authentication/form-action-providers') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/authentication/form-action-providers";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/:realm/authentication/form-action-providers

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/:realm/authentication/form-action-providers

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/authentication/form-action-providers")! 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}}/:realm/authentication/form-providers");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/:realm/authentication/form-providers")

require "http/client"

url = "{{baseUrl}}/:realm/authentication/form-providers"

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}}/:realm/authentication/form-providers"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/authentication/form-providers");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/:realm/authentication/form-providers"

	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/:realm/authentication/form-providers HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/:realm/authentication/form-providers")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/authentication/form-providers"))
    .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}}/:realm/authentication/form-providers")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/:realm/authentication/form-providers")
  .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}}/:realm/authentication/form-providers');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/:realm/authentication/form-providers'
};

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

const url = '{{baseUrl}}/:realm/authentication/form-providers';
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}}/:realm/authentication/form-providers',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/form-providers")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/authentication/form-providers',
  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}}/:realm/authentication/form-providers'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/:realm/authentication/form-providers');

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}}/:realm/authentication/form-providers'
};

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

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

const url = '{{baseUrl}}/:realm/authentication/form-providers';
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}}/:realm/authentication/form-providers"]
                                                       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}}/:realm/authentication/form-providers" in

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

 "{{baseUrl}}/:realm/authentication/form-providers",
  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}}/:realm/authentication/form-providers');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/authentication/form-providers');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/:realm/authentication/form-providers');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/authentication/form-providers' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/authentication/form-providers' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/:realm/authentication/form-providers")

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

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

import requests

url = "{{baseUrl}}/:realm/authentication/form-providers"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/authentication/form-providers"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/authentication/form-providers")

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/:realm/authentication/form-providers') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/authentication/form-providers";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/:realm/authentication/form-providers

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/:realm/authentication/form-providers

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/authentication/form-providers")! 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}}/:realm/authentication/required-actions/:alias");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/:realm/authentication/required-actions/:alias")

require "http/client"

url = "{{baseUrl}}/:realm/authentication/required-actions/:alias"

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}}/:realm/authentication/required-actions/:alias"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/authentication/required-actions/:alias");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/:realm/authentication/required-actions/:alias"

	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/:realm/authentication/required-actions/:alias HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/:realm/authentication/required-actions/:alias")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/authentication/required-actions/:alias"))
    .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}}/:realm/authentication/required-actions/:alias")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/:realm/authentication/required-actions/:alias")
  .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}}/:realm/authentication/required-actions/:alias');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/:realm/authentication/required-actions/:alias'
};

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

const url = '{{baseUrl}}/:realm/authentication/required-actions/:alias';
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}}/:realm/authentication/required-actions/:alias',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/required-actions/:alias")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/authentication/required-actions/:alias',
  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}}/:realm/authentication/required-actions/:alias'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/:realm/authentication/required-actions/:alias');

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}}/:realm/authentication/required-actions/:alias'
};

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

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

const url = '{{baseUrl}}/:realm/authentication/required-actions/:alias';
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}}/:realm/authentication/required-actions/:alias"]
                                                       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}}/:realm/authentication/required-actions/:alias" in

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

 "{{baseUrl}}/:realm/authentication/required-actions/:alias",
  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}}/:realm/authentication/required-actions/:alias');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/authentication/required-actions/:alias');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/:realm/authentication/required-actions/:alias');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/authentication/required-actions/:alias' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/authentication/required-actions/:alias' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/:realm/authentication/required-actions/:alias")

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

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

import requests

url = "{{baseUrl}}/:realm/authentication/required-actions/:alias"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/authentication/required-actions/:alias"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/authentication/required-actions/:alias")

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/:realm/authentication/required-actions/:alias') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/authentication/required-actions/:alias";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/:realm/authentication/required-actions/:alias

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/:realm/authentication/required-actions/:alias

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/authentication/required-actions/:alias")! 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}}/:realm/authentication/required-actions");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/:realm/authentication/required-actions")

require "http/client"

url = "{{baseUrl}}/:realm/authentication/required-actions"

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}}/:realm/authentication/required-actions"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/authentication/required-actions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/:realm/authentication/required-actions"

	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/:realm/authentication/required-actions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/:realm/authentication/required-actions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/authentication/required-actions"))
    .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}}/:realm/authentication/required-actions")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/:realm/authentication/required-actions")
  .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}}/:realm/authentication/required-actions');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/:realm/authentication/required-actions'
};

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

const url = '{{baseUrl}}/:realm/authentication/required-actions';
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}}/:realm/authentication/required-actions',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/required-actions")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/authentication/required-actions',
  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}}/:realm/authentication/required-actions'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/:realm/authentication/required-actions');

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}}/:realm/authentication/required-actions'
};

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

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

const url = '{{baseUrl}}/:realm/authentication/required-actions';
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}}/:realm/authentication/required-actions"]
                                                       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}}/:realm/authentication/required-actions" in

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

 "{{baseUrl}}/:realm/authentication/required-actions",
  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}}/:realm/authentication/required-actions');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/authentication/required-actions');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/:realm/authentication/required-actions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/authentication/required-actions' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/authentication/required-actions' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/:realm/authentication/required-actions")

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

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

import requests

url = "{{baseUrl}}/:realm/authentication/required-actions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/authentication/required-actions"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/authentication/required-actions")

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/:realm/authentication/required-actions') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/authentication/required-actions";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/:realm/authentication/required-actions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/:realm/authentication/required-actions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/authentication/required-actions")! 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}}/:realm/authentication/unregistered-required-actions");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/:realm/authentication/unregistered-required-actions")

require "http/client"

url = "{{baseUrl}}/:realm/authentication/unregistered-required-actions"

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}}/:realm/authentication/unregistered-required-actions"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/authentication/unregistered-required-actions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/:realm/authentication/unregistered-required-actions"

	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/:realm/authentication/unregistered-required-actions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/:realm/authentication/unregistered-required-actions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/authentication/unregistered-required-actions"))
    .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}}/:realm/authentication/unregistered-required-actions")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/:realm/authentication/unregistered-required-actions")
  .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}}/:realm/authentication/unregistered-required-actions');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/:realm/authentication/unregistered-required-actions'
};

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

const url = '{{baseUrl}}/:realm/authentication/unregistered-required-actions';
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}}/:realm/authentication/unregistered-required-actions',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/unregistered-required-actions")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/authentication/unregistered-required-actions',
  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}}/:realm/authentication/unregistered-required-actions'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/:realm/authentication/unregistered-required-actions');

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}}/:realm/authentication/unregistered-required-actions'
};

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

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

const url = '{{baseUrl}}/:realm/authentication/unregistered-required-actions';
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}}/:realm/authentication/unregistered-required-actions"]
                                                       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}}/:realm/authentication/unregistered-required-actions" in

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

 "{{baseUrl}}/:realm/authentication/unregistered-required-actions",
  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}}/:realm/authentication/unregistered-required-actions');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/authentication/unregistered-required-actions');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/:realm/authentication/unregistered-required-actions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/authentication/unregistered-required-actions' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/authentication/unregistered-required-actions' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/:realm/authentication/unregistered-required-actions")

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

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

import requests

url = "{{baseUrl}}/:realm/authentication/unregistered-required-actions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/authentication/unregistered-required-actions"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/authentication/unregistered-required-actions")

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/:realm/authentication/unregistered-required-actions') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/authentication/unregistered-required-actions";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/:realm/authentication/unregistered-required-actions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/:realm/authentication/unregistered-required-actions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/authentication/unregistered-required-actions")! 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}}/:realm/authentication/executions/:executionId/lower-priority");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/:realm/authentication/executions/:executionId/lower-priority")

require "http/client"

url = "{{baseUrl}}/:realm/authentication/executions/:executionId/lower-priority"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/:realm/authentication/executions/:executionId/lower-priority"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/authentication/executions/:executionId/lower-priority");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/:realm/authentication/executions/:executionId/lower-priority"

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

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

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

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

}

POST /baseUrl/:realm/authentication/executions/:executionId/lower-priority HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/:realm/authentication/executions/:executionId/lower-priority")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/authentication/executions/:executionId/lower-priority"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/executions/:executionId/lower-priority")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/:realm/authentication/executions/:executionId/lower-priority")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/:realm/authentication/executions/:executionId/lower-priority');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/authentication/executions/:executionId/lower-priority'
};

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

const url = '{{baseUrl}}/:realm/authentication/executions/:executionId/lower-priority';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/:realm/authentication/executions/:executionId/lower-priority',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/executions/:executionId/lower-priority")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/authentication/executions/:executionId/lower-priority',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/authentication/executions/:executionId/lower-priority'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/:realm/authentication/executions/:executionId/lower-priority');

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/authentication/executions/:executionId/lower-priority'
};

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

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

const url = '{{baseUrl}}/:realm/authentication/executions/:executionId/lower-priority';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/:realm/authentication/executions/:executionId/lower-priority"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/:realm/authentication/executions/:executionId/lower-priority" in

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

 "{{baseUrl}}/:realm/authentication/executions/:executionId/lower-priority",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/:realm/authentication/executions/:executionId/lower-priority');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/authentication/executions/:executionId/lower-priority');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/:realm/authentication/executions/:executionId/lower-priority');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/authentication/executions/:executionId/lower-priority' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/authentication/executions/:executionId/lower-priority' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/:realm/authentication/executions/:executionId/lower-priority")

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

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/:realm/authentication/executions/:executionId/lower-priority"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/authentication/executions/:executionId/lower-priority"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/authentication/executions/:executionId/lower-priority")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/:realm/authentication/executions/:executionId/lower-priority') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/authentication/executions/:executionId/lower-priority";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/:realm/authentication/executions/:executionId/lower-priority

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/:realm/authentication/executions/:executionId/lower-priority

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/authentication/executions/:executionId/lower-priority")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/:realm/authentication/required-actions/:alias/lower-priority");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/:realm/authentication/required-actions/:alias/lower-priority")

require "http/client"

url = "{{baseUrl}}/:realm/authentication/required-actions/:alias/lower-priority"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/:realm/authentication/required-actions/:alias/lower-priority"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/authentication/required-actions/:alias/lower-priority");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/:realm/authentication/required-actions/:alias/lower-priority"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/:realm/authentication/required-actions/:alias/lower-priority HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/:realm/authentication/required-actions/:alias/lower-priority")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/authentication/required-actions/:alias/lower-priority"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/required-actions/:alias/lower-priority")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/:realm/authentication/required-actions/:alias/lower-priority")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/:realm/authentication/required-actions/:alias/lower-priority');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/authentication/required-actions/:alias/lower-priority'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/:realm/authentication/required-actions/:alias/lower-priority';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/:realm/authentication/required-actions/:alias/lower-priority',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/required-actions/:alias/lower-priority")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/authentication/required-actions/:alias/lower-priority',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/authentication/required-actions/:alias/lower-priority'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/:realm/authentication/required-actions/:alias/lower-priority');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/authentication/required-actions/:alias/lower-priority'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/:realm/authentication/required-actions/:alias/lower-priority';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/:realm/authentication/required-actions/:alias/lower-priority"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/:realm/authentication/required-actions/:alias/lower-priority" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/:realm/authentication/required-actions/:alias/lower-priority",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/:realm/authentication/required-actions/:alias/lower-priority');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/authentication/required-actions/:alias/lower-priority');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/:realm/authentication/required-actions/:alias/lower-priority');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/authentication/required-actions/:alias/lower-priority' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/authentication/required-actions/:alias/lower-priority' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/:realm/authentication/required-actions/:alias/lower-priority")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/:realm/authentication/required-actions/:alias/lower-priority"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/authentication/required-actions/:alias/lower-priority"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/authentication/required-actions/:alias/lower-priority")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/:realm/authentication/required-actions/:alias/lower-priority') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/authentication/required-actions/:alias/lower-priority";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/:realm/authentication/required-actions/:alias/lower-priority

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/:realm/authentication/required-actions/:alias/lower-priority

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/authentication/required-actions/:alias/lower-priority")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/:realm/authentication/executions/:executionId/raise-priority");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/:realm/authentication/executions/:executionId/raise-priority")

require "http/client"

url = "{{baseUrl}}/:realm/authentication/executions/:executionId/raise-priority"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/:realm/authentication/executions/:executionId/raise-priority"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/authentication/executions/:executionId/raise-priority");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/:realm/authentication/executions/:executionId/raise-priority"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/:realm/authentication/executions/:executionId/raise-priority HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/:realm/authentication/executions/:executionId/raise-priority")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/authentication/executions/:executionId/raise-priority"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/executions/:executionId/raise-priority")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/:realm/authentication/executions/:executionId/raise-priority")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/:realm/authentication/executions/:executionId/raise-priority');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/authentication/executions/:executionId/raise-priority'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/:realm/authentication/executions/:executionId/raise-priority';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/:realm/authentication/executions/:executionId/raise-priority',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/executions/:executionId/raise-priority")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/authentication/executions/:executionId/raise-priority',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/authentication/executions/:executionId/raise-priority'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/:realm/authentication/executions/:executionId/raise-priority');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/authentication/executions/:executionId/raise-priority'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/:realm/authentication/executions/:executionId/raise-priority';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/:realm/authentication/executions/:executionId/raise-priority"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/:realm/authentication/executions/:executionId/raise-priority" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/:realm/authentication/executions/:executionId/raise-priority",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/:realm/authentication/executions/:executionId/raise-priority');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/authentication/executions/:executionId/raise-priority');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/:realm/authentication/executions/:executionId/raise-priority');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/authentication/executions/:executionId/raise-priority' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/authentication/executions/:executionId/raise-priority' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/:realm/authentication/executions/:executionId/raise-priority")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/:realm/authentication/executions/:executionId/raise-priority"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/authentication/executions/:executionId/raise-priority"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/authentication/executions/:executionId/raise-priority")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/:realm/authentication/executions/:executionId/raise-priority') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/authentication/executions/:executionId/raise-priority";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/:realm/authentication/executions/:executionId/raise-priority

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/:realm/authentication/executions/:executionId/raise-priority

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/authentication/executions/:executionId/raise-priority")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/:realm/authentication/required-actions/:alias/raise-priority");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/:realm/authentication/required-actions/:alias/raise-priority")

require "http/client"

url = "{{baseUrl}}/:realm/authentication/required-actions/:alias/raise-priority"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/:realm/authentication/required-actions/:alias/raise-priority"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/authentication/required-actions/:alias/raise-priority");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/:realm/authentication/required-actions/:alias/raise-priority"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/:realm/authentication/required-actions/:alias/raise-priority HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/:realm/authentication/required-actions/:alias/raise-priority")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/authentication/required-actions/:alias/raise-priority"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/required-actions/:alias/raise-priority")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/:realm/authentication/required-actions/:alias/raise-priority")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/:realm/authentication/required-actions/:alias/raise-priority');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/authentication/required-actions/:alias/raise-priority'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/:realm/authentication/required-actions/:alias/raise-priority';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/:realm/authentication/required-actions/:alias/raise-priority',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/required-actions/:alias/raise-priority")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/authentication/required-actions/:alias/raise-priority',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/authentication/required-actions/:alias/raise-priority'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/:realm/authentication/required-actions/:alias/raise-priority');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/authentication/required-actions/:alias/raise-priority'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/:realm/authentication/required-actions/:alias/raise-priority';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/:realm/authentication/required-actions/:alias/raise-priority"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/:realm/authentication/required-actions/:alias/raise-priority" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/:realm/authentication/required-actions/:alias/raise-priority",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/:realm/authentication/required-actions/:alias/raise-priority');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/authentication/required-actions/:alias/raise-priority');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/:realm/authentication/required-actions/:alias/raise-priority');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/authentication/required-actions/:alias/raise-priority' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/authentication/required-actions/:alias/raise-priority' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/:realm/authentication/required-actions/:alias/raise-priority")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/:realm/authentication/required-actions/:alias/raise-priority"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/authentication/required-actions/:alias/raise-priority"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/authentication/required-actions/:alias/raise-priority")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/:realm/authentication/required-actions/:alias/raise-priority') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/authentication/required-actions/:alias/raise-priority";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/:realm/authentication/required-actions/:alias/raise-priority

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/:realm/authentication/required-actions/:alias/raise-priority

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/authentication/required-actions/:alias/raise-priority")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/:realm/authentication/register-required-action");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/:realm/authentication/register-required-action" {:content-type :json})

require "http/client"

url = "{{baseUrl}}/:realm/authentication/register-required-action"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{}"

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}}/:realm/authentication/register-required-action"),
    Content = new StringContent("{}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/authentication/register-required-action");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/:realm/authentication/register-required-action"

	payload := strings.NewReader("{}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/:realm/authentication/register-required-action HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 2

{}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/:realm/authentication/register-required-action")
  .setHeader("content-type", "application/json")
  .setBody("{}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/authentication/register-required-action"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/register-required-action")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/:realm/authentication/register-required-action")
  .header("content-type", "application/json")
  .body("{}")
  .asString();

const data = JSON.stringify({});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/:realm/authentication/register-required-action');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/authentication/register-required-action',
  headers: {'content-type': 'application/json'},
  data: {}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/:realm/authentication/register-required-action';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '{}'};

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}}/:realm/authentication/register-required-action',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{}")
val request = Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/register-required-action")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/authentication/register-required-action',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/authentication/register-required-action',
  headers: {'content-type': 'application/json'},
  body: {},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/:realm/authentication/register-required-action');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/authentication/register-required-action',
  headers: {'content-type': 'application/json'},
  data: {}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/:realm/authentication/register-required-action';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '{}'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{  };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/:realm/authentication/register-required-action"]
                                                       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}}/:realm/authentication/register-required-action" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/:realm/authentication/register-required-action",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/:realm/authentication/register-required-action', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/authentication/register-required-action');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  
]));
$request->setRequestUrl('{{baseUrl}}/:realm/authentication/register-required-action');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/authentication/register-required-action' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/authentication/register-required-action' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/:realm/authentication/register-required-action", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/:realm/authentication/register-required-action"

payload = {}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/authentication/register-required-action"

payload <- "{}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/authentication/register-required-action")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/:realm/authentication/register-required-action') do |req|
  req.body = "{}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/authentication/register-required-action";

    let payload = json!({});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{}' |  \
  http POST {{baseUrl}}/:realm/authentication/register-required-action \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - {{baseUrl}}/:realm/authentication/register-required-action

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/authentication/register-required-action")! 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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/:realm/authentication/flows/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"alias\": \"\",\n  \"authenticationExecutions\": [\n    {\n      \"authenticator\": \"\",\n      \"authenticatorConfig\": \"\",\n      \"authenticatorFlow\": false,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"priority\": 0,\n      \"requirement\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ],\n  \"builtIn\": false,\n  \"description\": \"\",\n  \"id\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/:realm/authentication/flows/:id" {:content-type :json
                                                                           :form-params {:alias ""
                                                                                         :authenticationExecutions [{:authenticator ""
                                                                                                                     :authenticatorConfig ""
                                                                                                                     :authenticatorFlow false
                                                                                                                     :autheticatorFlow false
                                                                                                                     :flowAlias ""
                                                                                                                     :priority 0
                                                                                                                     :requirement ""
                                                                                                                     :userSetupAllowed false}]
                                                                                         :builtIn false
                                                                                         :description ""
                                                                                         :id ""
                                                                                         :providerId ""
                                                                                         :topLevel false}})

require "http/client"

url = "{{baseUrl}}/:realm/authentication/flows/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"alias\": \"\",\n  \"authenticationExecutions\": [\n    {\n      \"authenticator\": \"\",\n      \"authenticatorConfig\": \"\",\n      \"authenticatorFlow\": false,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"priority\": 0,\n      \"requirement\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ],\n  \"builtIn\": false,\n  \"description\": \"\",\n  \"id\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/:realm/authentication/flows/:id"),
    Content = new StringContent("{\n  \"alias\": \"\",\n  \"authenticationExecutions\": [\n    {\n      \"authenticator\": \"\",\n      \"authenticatorConfig\": \"\",\n      \"authenticatorFlow\": false,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"priority\": 0,\n      \"requirement\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ],\n  \"builtIn\": false,\n  \"description\": \"\",\n  \"id\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/authentication/flows/:id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"alias\": \"\",\n  \"authenticationExecutions\": [\n    {\n      \"authenticator\": \"\",\n      \"authenticatorConfig\": \"\",\n      \"authenticatorFlow\": false,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"priority\": 0,\n      \"requirement\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ],\n  \"builtIn\": false,\n  \"description\": \"\",\n  \"id\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/:realm/authentication/flows/:id"

	payload := strings.NewReader("{\n  \"alias\": \"\",\n  \"authenticationExecutions\": [\n    {\n      \"authenticator\": \"\",\n      \"authenticatorConfig\": \"\",\n      \"authenticatorFlow\": false,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"priority\": 0,\n      \"requirement\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ],\n  \"builtIn\": false,\n  \"description\": \"\",\n  \"id\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/:realm/authentication/flows/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 388

{
  "alias": "",
  "authenticationExecutions": [
    {
      "authenticator": "",
      "authenticatorConfig": "",
      "authenticatorFlow": false,
      "autheticatorFlow": false,
      "flowAlias": "",
      "priority": 0,
      "requirement": "",
      "userSetupAllowed": false
    }
  ],
  "builtIn": false,
  "description": "",
  "id": "",
  "providerId": "",
  "topLevel": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/:realm/authentication/flows/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"alias\": \"\",\n  \"authenticationExecutions\": [\n    {\n      \"authenticator\": \"\",\n      \"authenticatorConfig\": \"\",\n      \"authenticatorFlow\": false,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"priority\": 0,\n      \"requirement\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ],\n  \"builtIn\": false,\n  \"description\": \"\",\n  \"id\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/authentication/flows/:id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"alias\": \"\",\n  \"authenticationExecutions\": [\n    {\n      \"authenticator\": \"\",\n      \"authenticatorConfig\": \"\",\n      \"authenticatorFlow\": false,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"priority\": 0,\n      \"requirement\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ],\n  \"builtIn\": false,\n  \"description\": \"\",\n  \"id\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"alias\": \"\",\n  \"authenticationExecutions\": [\n    {\n      \"authenticator\": \"\",\n      \"authenticatorConfig\": \"\",\n      \"authenticatorFlow\": false,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"priority\": 0,\n      \"requirement\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ],\n  \"builtIn\": false,\n  \"description\": \"\",\n  \"id\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/flows/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/:realm/authentication/flows/:id")
  .header("content-type", "application/json")
  .body("{\n  \"alias\": \"\",\n  \"authenticationExecutions\": [\n    {\n      \"authenticator\": \"\",\n      \"authenticatorConfig\": \"\",\n      \"authenticatorFlow\": false,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"priority\": 0,\n      \"requirement\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ],\n  \"builtIn\": false,\n  \"description\": \"\",\n  \"id\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false\n}")
  .asString();

const data = JSON.stringify({
  alias: '',
  authenticationExecutions: [
    {
      authenticator: '',
      authenticatorConfig: '',
      authenticatorFlow: false,
      autheticatorFlow: false,
      flowAlias: '',
      priority: 0,
      requirement: '',
      userSetupAllowed: false
    }
  ],
  builtIn: false,
  description: '',
  id: '',
  providerId: '',
  topLevel: false
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/:realm/authentication/flows/:id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/:realm/authentication/flows/:id',
  headers: {'content-type': 'application/json'},
  data: {
    alias: '',
    authenticationExecutions: [
      {
        authenticator: '',
        authenticatorConfig: '',
        authenticatorFlow: false,
        autheticatorFlow: false,
        flowAlias: '',
        priority: 0,
        requirement: '',
        userSetupAllowed: false
      }
    ],
    builtIn: false,
    description: '',
    id: '',
    providerId: '',
    topLevel: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/:realm/authentication/flows/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"alias":"","authenticationExecutions":[{"authenticator":"","authenticatorConfig":"","authenticatorFlow":false,"autheticatorFlow":false,"flowAlias":"","priority":0,"requirement":"","userSetupAllowed":false}],"builtIn":false,"description":"","id":"","providerId":"","topLevel":false}'
};

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}}/:realm/authentication/flows/:id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "alias": "",\n  "authenticationExecutions": [\n    {\n      "authenticator": "",\n      "authenticatorConfig": "",\n      "authenticatorFlow": false,\n      "autheticatorFlow": false,\n      "flowAlias": "",\n      "priority": 0,\n      "requirement": "",\n      "userSetupAllowed": false\n    }\n  ],\n  "builtIn": false,\n  "description": "",\n  "id": "",\n  "providerId": "",\n  "topLevel": false\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"alias\": \"\",\n  \"authenticationExecutions\": [\n    {\n      \"authenticator\": \"\",\n      \"authenticatorConfig\": \"\",\n      \"authenticatorFlow\": false,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"priority\": 0,\n      \"requirement\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ],\n  \"builtIn\": false,\n  \"description\": \"\",\n  \"id\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/flows/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/authentication/flows/:id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  alias: '',
  authenticationExecutions: [
    {
      authenticator: '',
      authenticatorConfig: '',
      authenticatorFlow: false,
      autheticatorFlow: false,
      flowAlias: '',
      priority: 0,
      requirement: '',
      userSetupAllowed: false
    }
  ],
  builtIn: false,
  description: '',
  id: '',
  providerId: '',
  topLevel: false
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/:realm/authentication/flows/:id',
  headers: {'content-type': 'application/json'},
  body: {
    alias: '',
    authenticationExecutions: [
      {
        authenticator: '',
        authenticatorConfig: '',
        authenticatorFlow: false,
        autheticatorFlow: false,
        flowAlias: '',
        priority: 0,
        requirement: '',
        userSetupAllowed: false
      }
    ],
    builtIn: false,
    description: '',
    id: '',
    providerId: '',
    topLevel: false
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/:realm/authentication/flows/:id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  alias: '',
  authenticationExecutions: [
    {
      authenticator: '',
      authenticatorConfig: '',
      authenticatorFlow: false,
      autheticatorFlow: false,
      flowAlias: '',
      priority: 0,
      requirement: '',
      userSetupAllowed: false
    }
  ],
  builtIn: false,
  description: '',
  id: '',
  providerId: '',
  topLevel: false
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/:realm/authentication/flows/:id',
  headers: {'content-type': 'application/json'},
  data: {
    alias: '',
    authenticationExecutions: [
      {
        authenticator: '',
        authenticatorConfig: '',
        authenticatorFlow: false,
        autheticatorFlow: false,
        flowAlias: '',
        priority: 0,
        requirement: '',
        userSetupAllowed: false
      }
    ],
    builtIn: false,
    description: '',
    id: '',
    providerId: '',
    topLevel: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/:realm/authentication/flows/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"alias":"","authenticationExecutions":[{"authenticator":"","authenticatorConfig":"","authenticatorFlow":false,"autheticatorFlow":false,"flowAlias":"","priority":0,"requirement":"","userSetupAllowed":false}],"builtIn":false,"description":"","id":"","providerId":"","topLevel":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"alias": @"",
                              @"authenticationExecutions": @[ @{ @"authenticator": @"", @"authenticatorConfig": @"", @"authenticatorFlow": @NO, @"autheticatorFlow": @NO, @"flowAlias": @"", @"priority": @0, @"requirement": @"", @"userSetupAllowed": @NO } ],
                              @"builtIn": @NO,
                              @"description": @"",
                              @"id": @"",
                              @"providerId": @"",
                              @"topLevel": @NO };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/:realm/authentication/flows/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/:realm/authentication/flows/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"alias\": \"\",\n  \"authenticationExecutions\": [\n    {\n      \"authenticator\": \"\",\n      \"authenticatorConfig\": \"\",\n      \"authenticatorFlow\": false,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"priority\": 0,\n      \"requirement\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ],\n  \"builtIn\": false,\n  \"description\": \"\",\n  \"id\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/:realm/authentication/flows/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'alias' => '',
    'authenticationExecutions' => [
        [
                'authenticator' => '',
                'authenticatorConfig' => '',
                'authenticatorFlow' => null,
                'autheticatorFlow' => null,
                'flowAlias' => '',
                'priority' => 0,
                'requirement' => '',
                'userSetupAllowed' => null
        ]
    ],
    'builtIn' => null,
    'description' => '',
    'id' => '',
    'providerId' => '',
    'topLevel' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/:realm/authentication/flows/:id', [
  'body' => '{
  "alias": "",
  "authenticationExecutions": [
    {
      "authenticator": "",
      "authenticatorConfig": "",
      "authenticatorFlow": false,
      "autheticatorFlow": false,
      "flowAlias": "",
      "priority": 0,
      "requirement": "",
      "userSetupAllowed": false
    }
  ],
  "builtIn": false,
  "description": "",
  "id": "",
  "providerId": "",
  "topLevel": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/authentication/flows/:id');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'alias' => '',
  'authenticationExecutions' => [
    [
        'authenticator' => '',
        'authenticatorConfig' => '',
        'authenticatorFlow' => null,
        'autheticatorFlow' => null,
        'flowAlias' => '',
        'priority' => 0,
        'requirement' => '',
        'userSetupAllowed' => null
    ]
  ],
  'builtIn' => null,
  'description' => '',
  'id' => '',
  'providerId' => '',
  'topLevel' => null
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'alias' => '',
  'authenticationExecutions' => [
    [
        'authenticator' => '',
        'authenticatorConfig' => '',
        'authenticatorFlow' => null,
        'autheticatorFlow' => null,
        'flowAlias' => '',
        'priority' => 0,
        'requirement' => '',
        'userSetupAllowed' => null
    ]
  ],
  'builtIn' => null,
  'description' => '',
  'id' => '',
  'providerId' => '',
  'topLevel' => null
]));
$request->setRequestUrl('{{baseUrl}}/:realm/authentication/flows/:id');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/authentication/flows/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "alias": "",
  "authenticationExecutions": [
    {
      "authenticator": "",
      "authenticatorConfig": "",
      "authenticatorFlow": false,
      "autheticatorFlow": false,
      "flowAlias": "",
      "priority": 0,
      "requirement": "",
      "userSetupAllowed": false
    }
  ],
  "builtIn": false,
  "description": "",
  "id": "",
  "providerId": "",
  "topLevel": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/authentication/flows/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "alias": "",
  "authenticationExecutions": [
    {
      "authenticator": "",
      "authenticatorConfig": "",
      "authenticatorFlow": false,
      "autheticatorFlow": false,
      "flowAlias": "",
      "priority": 0,
      "requirement": "",
      "userSetupAllowed": false
    }
  ],
  "builtIn": false,
  "description": "",
  "id": "",
  "providerId": "",
  "topLevel": false
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"alias\": \"\",\n  \"authenticationExecutions\": [\n    {\n      \"authenticator\": \"\",\n      \"authenticatorConfig\": \"\",\n      \"authenticatorFlow\": false,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"priority\": 0,\n      \"requirement\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ],\n  \"builtIn\": false,\n  \"description\": \"\",\n  \"id\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/:realm/authentication/flows/:id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/:realm/authentication/flows/:id"

payload = {
    "alias": "",
    "authenticationExecutions": [
        {
            "authenticator": "",
            "authenticatorConfig": "",
            "authenticatorFlow": False,
            "autheticatorFlow": False,
            "flowAlias": "",
            "priority": 0,
            "requirement": "",
            "userSetupAllowed": False
        }
    ],
    "builtIn": False,
    "description": "",
    "id": "",
    "providerId": "",
    "topLevel": False
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/authentication/flows/:id"

payload <- "{\n  \"alias\": \"\",\n  \"authenticationExecutions\": [\n    {\n      \"authenticator\": \"\",\n      \"authenticatorConfig\": \"\",\n      \"authenticatorFlow\": false,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"priority\": 0,\n      \"requirement\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ],\n  \"builtIn\": false,\n  \"description\": \"\",\n  \"id\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/authentication/flows/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"alias\": \"\",\n  \"authenticationExecutions\": [\n    {\n      \"authenticator\": \"\",\n      \"authenticatorConfig\": \"\",\n      \"authenticatorFlow\": false,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"priority\": 0,\n      \"requirement\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ],\n  \"builtIn\": false,\n  \"description\": \"\",\n  \"id\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/:realm/authentication/flows/:id') do |req|
  req.body = "{\n  \"alias\": \"\",\n  \"authenticationExecutions\": [\n    {\n      \"authenticator\": \"\",\n      \"authenticatorConfig\": \"\",\n      \"authenticatorFlow\": false,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"priority\": 0,\n      \"requirement\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ],\n  \"builtIn\": false,\n  \"description\": \"\",\n  \"id\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/authentication/flows/:id";

    let payload = json!({
        "alias": "",
        "authenticationExecutions": (
            json!({
                "authenticator": "",
                "authenticatorConfig": "",
                "authenticatorFlow": false,
                "autheticatorFlow": false,
                "flowAlias": "",
                "priority": 0,
                "requirement": "",
                "userSetupAllowed": false
            })
        ),
        "builtIn": false,
        "description": "",
        "id": "",
        "providerId": "",
        "topLevel": false
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "alias": "",
  "authenticationExecutions": [
    {
      "authenticator": "",
      "authenticatorConfig": "",
      "authenticatorFlow": false,
      "autheticatorFlow": false,
      "flowAlias": "",
      "priority": 0,
      "requirement": "",
      "userSetupAllowed": false
    }
  ],
  "builtIn": false,
  "description": "",
  "id": "",
  "providerId": "",
  "topLevel": false
}' |  \
  http PUT {{baseUrl}}/:realm/authentication/flows/:id \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "alias": "",\n  "authenticationExecutions": [\n    {\n      "authenticator": "",\n      "authenticatorConfig": "",\n      "authenticatorFlow": false,\n      "autheticatorFlow": false,\n      "flowAlias": "",\n      "priority": 0,\n      "requirement": "",\n      "userSetupAllowed": false\n    }\n  ],\n  "builtIn": false,\n  "description": "",\n  "id": "",\n  "providerId": "",\n  "topLevel": false\n}' \
  --output-document \
  - {{baseUrl}}/:realm/authentication/flows/:id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "alias": "",
  "authenticationExecutions": [
    [
      "authenticator": "",
      "authenticatorConfig": "",
      "authenticatorFlow": false,
      "autheticatorFlow": false,
      "flowAlias": "",
      "priority": 0,
      "requirement": "",
      "userSetupAllowed": false
    ]
  ],
  "builtIn": false,
  "description": "",
  "id": "",
  "providerId": "",
  "topLevel": false
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/authentication/flows/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"alias\": \"\",\n  \"authenticationConfig\": \"\",\n  \"authenticationFlow\": false,\n  \"configurable\": false,\n  \"displayName\": \"\",\n  \"flowId\": \"\",\n  \"id\": \"\",\n  \"index\": 0,\n  \"level\": 0,\n  \"providerId\": \"\",\n  \"requirement\": \"\",\n  \"requirementChoices\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions" {:content-type :json
                                                                                             :form-params {:alias ""
                                                                                                           :authenticationConfig ""
                                                                                                           :authenticationFlow false
                                                                                                           :configurable false
                                                                                                           :displayName ""
                                                                                                           :flowId ""
                                                                                                           :id ""
                                                                                                           :index 0
                                                                                                           :level 0
                                                                                                           :providerId ""
                                                                                                           :requirement ""
                                                                                                           :requirementChoices []}})

require "http/client"

url = "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"alias\": \"\",\n  \"authenticationConfig\": \"\",\n  \"authenticationFlow\": false,\n  \"configurable\": false,\n  \"displayName\": \"\",\n  \"flowId\": \"\",\n  \"id\": \"\",\n  \"index\": 0,\n  \"level\": 0,\n  \"providerId\": \"\",\n  \"requirement\": \"\",\n  \"requirementChoices\": []\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions"),
    Content = new StringContent("{\n  \"alias\": \"\",\n  \"authenticationConfig\": \"\",\n  \"authenticationFlow\": false,\n  \"configurable\": false,\n  \"displayName\": \"\",\n  \"flowId\": \"\",\n  \"id\": \"\",\n  \"index\": 0,\n  \"level\": 0,\n  \"providerId\": \"\",\n  \"requirement\": \"\",\n  \"requirementChoices\": []\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"alias\": \"\",\n  \"authenticationConfig\": \"\",\n  \"authenticationFlow\": false,\n  \"configurable\": false,\n  \"displayName\": \"\",\n  \"flowId\": \"\",\n  \"id\": \"\",\n  \"index\": 0,\n  \"level\": 0,\n  \"providerId\": \"\",\n  \"requirement\": \"\",\n  \"requirementChoices\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions"

	payload := strings.NewReader("{\n  \"alias\": \"\",\n  \"authenticationConfig\": \"\",\n  \"authenticationFlow\": false,\n  \"configurable\": false,\n  \"displayName\": \"\",\n  \"flowId\": \"\",\n  \"id\": \"\",\n  \"index\": 0,\n  \"level\": 0,\n  \"providerId\": \"\",\n  \"requirement\": \"\",\n  \"requirementChoices\": []\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/:realm/authentication/flows/:flowAlias/executions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 249

{
  "alias": "",
  "authenticationConfig": "",
  "authenticationFlow": false,
  "configurable": false,
  "displayName": "",
  "flowId": "",
  "id": "",
  "index": 0,
  "level": 0,
  "providerId": "",
  "requirement": "",
  "requirementChoices": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"alias\": \"\",\n  \"authenticationConfig\": \"\",\n  \"authenticationFlow\": false,\n  \"configurable\": false,\n  \"displayName\": \"\",\n  \"flowId\": \"\",\n  \"id\": \"\",\n  \"index\": 0,\n  \"level\": 0,\n  \"providerId\": \"\",\n  \"requirement\": \"\",\n  \"requirementChoices\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"alias\": \"\",\n  \"authenticationConfig\": \"\",\n  \"authenticationFlow\": false,\n  \"configurable\": false,\n  \"displayName\": \"\",\n  \"flowId\": \"\",\n  \"id\": \"\",\n  \"index\": 0,\n  \"level\": 0,\n  \"providerId\": \"\",\n  \"requirement\": \"\",\n  \"requirementChoices\": []\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"alias\": \"\",\n  \"authenticationConfig\": \"\",\n  \"authenticationFlow\": false,\n  \"configurable\": false,\n  \"displayName\": \"\",\n  \"flowId\": \"\",\n  \"id\": \"\",\n  \"index\": 0,\n  \"level\": 0,\n  \"providerId\": \"\",\n  \"requirement\": \"\",\n  \"requirementChoices\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions")
  .header("content-type", "application/json")
  .body("{\n  \"alias\": \"\",\n  \"authenticationConfig\": \"\",\n  \"authenticationFlow\": false,\n  \"configurable\": false,\n  \"displayName\": \"\",\n  \"flowId\": \"\",\n  \"id\": \"\",\n  \"index\": 0,\n  \"level\": 0,\n  \"providerId\": \"\",\n  \"requirement\": \"\",\n  \"requirementChoices\": []\n}")
  .asString();

const data = JSON.stringify({
  alias: '',
  authenticationConfig: '',
  authenticationFlow: false,
  configurable: false,
  displayName: '',
  flowId: '',
  id: '',
  index: 0,
  level: 0,
  providerId: '',
  requirement: '',
  requirementChoices: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions',
  headers: {'content-type': 'application/json'},
  data: {
    alias: '',
    authenticationConfig: '',
    authenticationFlow: false,
    configurable: false,
    displayName: '',
    flowId: '',
    id: '',
    index: 0,
    level: 0,
    providerId: '',
    requirement: '',
    requirementChoices: []
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"alias":"","authenticationConfig":"","authenticationFlow":false,"configurable":false,"displayName":"","flowId":"","id":"","index":0,"level":0,"providerId":"","requirement":"","requirementChoices":[]}'
};

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}}/:realm/authentication/flows/:flowAlias/executions',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "alias": "",\n  "authenticationConfig": "",\n  "authenticationFlow": false,\n  "configurable": false,\n  "displayName": "",\n  "flowId": "",\n  "id": "",\n  "index": 0,\n  "level": 0,\n  "providerId": "",\n  "requirement": "",\n  "requirementChoices": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"alias\": \"\",\n  \"authenticationConfig\": \"\",\n  \"authenticationFlow\": false,\n  \"configurable\": false,\n  \"displayName\": \"\",\n  \"flowId\": \"\",\n  \"id\": \"\",\n  \"index\": 0,\n  \"level\": 0,\n  \"providerId\": \"\",\n  \"requirement\": \"\",\n  \"requirementChoices\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/authentication/flows/:flowAlias/executions',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  alias: '',
  authenticationConfig: '',
  authenticationFlow: false,
  configurable: false,
  displayName: '',
  flowId: '',
  id: '',
  index: 0,
  level: 0,
  providerId: '',
  requirement: '',
  requirementChoices: []
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions',
  headers: {'content-type': 'application/json'},
  body: {
    alias: '',
    authenticationConfig: '',
    authenticationFlow: false,
    configurable: false,
    displayName: '',
    flowId: '',
    id: '',
    index: 0,
    level: 0,
    providerId: '',
    requirement: '',
    requirementChoices: []
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  alias: '',
  authenticationConfig: '',
  authenticationFlow: false,
  configurable: false,
  displayName: '',
  flowId: '',
  id: '',
  index: 0,
  level: 0,
  providerId: '',
  requirement: '',
  requirementChoices: []
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions',
  headers: {'content-type': 'application/json'},
  data: {
    alias: '',
    authenticationConfig: '',
    authenticationFlow: false,
    configurable: false,
    displayName: '',
    flowId: '',
    id: '',
    index: 0,
    level: 0,
    providerId: '',
    requirement: '',
    requirementChoices: []
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"alias":"","authenticationConfig":"","authenticationFlow":false,"configurable":false,"displayName":"","flowId":"","id":"","index":0,"level":0,"providerId":"","requirement":"","requirementChoices":[]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"alias": @"",
                              @"authenticationConfig": @"",
                              @"authenticationFlow": @NO,
                              @"configurable": @NO,
                              @"displayName": @"",
                              @"flowId": @"",
                              @"id": @"",
                              @"index": @0,
                              @"level": @0,
                              @"providerId": @"",
                              @"requirement": @"",
                              @"requirementChoices": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"alias\": \"\",\n  \"authenticationConfig\": \"\",\n  \"authenticationFlow\": false,\n  \"configurable\": false,\n  \"displayName\": \"\",\n  \"flowId\": \"\",\n  \"id\": \"\",\n  \"index\": 0,\n  \"level\": 0,\n  \"providerId\": \"\",\n  \"requirement\": \"\",\n  \"requirementChoices\": []\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'alias' => '',
    'authenticationConfig' => '',
    'authenticationFlow' => null,
    'configurable' => null,
    'displayName' => '',
    'flowId' => '',
    'id' => '',
    'index' => 0,
    'level' => 0,
    'providerId' => '',
    'requirement' => '',
    'requirementChoices' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions', [
  'body' => '{
  "alias": "",
  "authenticationConfig": "",
  "authenticationFlow": false,
  "configurable": false,
  "displayName": "",
  "flowId": "",
  "id": "",
  "index": 0,
  "level": 0,
  "providerId": "",
  "requirement": "",
  "requirementChoices": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'alias' => '',
  'authenticationConfig' => '',
  'authenticationFlow' => null,
  'configurable' => null,
  'displayName' => '',
  'flowId' => '',
  'id' => '',
  'index' => 0,
  'level' => 0,
  'providerId' => '',
  'requirement' => '',
  'requirementChoices' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'alias' => '',
  'authenticationConfig' => '',
  'authenticationFlow' => null,
  'configurable' => null,
  'displayName' => '',
  'flowId' => '',
  'id' => '',
  'index' => 0,
  'level' => 0,
  'providerId' => '',
  'requirement' => '',
  'requirementChoices' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "alias": "",
  "authenticationConfig": "",
  "authenticationFlow": false,
  "configurable": false,
  "displayName": "",
  "flowId": "",
  "id": "",
  "index": 0,
  "level": 0,
  "providerId": "",
  "requirement": "",
  "requirementChoices": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "alias": "",
  "authenticationConfig": "",
  "authenticationFlow": false,
  "configurable": false,
  "displayName": "",
  "flowId": "",
  "id": "",
  "index": 0,
  "level": 0,
  "providerId": "",
  "requirement": "",
  "requirementChoices": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"alias\": \"\",\n  \"authenticationConfig\": \"\",\n  \"authenticationFlow\": false,\n  \"configurable\": false,\n  \"displayName\": \"\",\n  \"flowId\": \"\",\n  \"id\": \"\",\n  \"index\": 0,\n  \"level\": 0,\n  \"providerId\": \"\",\n  \"requirement\": \"\",\n  \"requirementChoices\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/:realm/authentication/flows/:flowAlias/executions", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions"

payload = {
    "alias": "",
    "authenticationConfig": "",
    "authenticationFlow": False,
    "configurable": False,
    "displayName": "",
    "flowId": "",
    "id": "",
    "index": 0,
    "level": 0,
    "providerId": "",
    "requirement": "",
    "requirementChoices": []
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions"

payload <- "{\n  \"alias\": \"\",\n  \"authenticationConfig\": \"\",\n  \"authenticationFlow\": false,\n  \"configurable\": false,\n  \"displayName\": \"\",\n  \"flowId\": \"\",\n  \"id\": \"\",\n  \"index\": 0,\n  \"level\": 0,\n  \"providerId\": \"\",\n  \"requirement\": \"\",\n  \"requirementChoices\": []\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"alias\": \"\",\n  \"authenticationConfig\": \"\",\n  \"authenticationFlow\": false,\n  \"configurable\": false,\n  \"displayName\": \"\",\n  \"flowId\": \"\",\n  \"id\": \"\",\n  \"index\": 0,\n  \"level\": 0,\n  \"providerId\": \"\",\n  \"requirement\": \"\",\n  \"requirementChoices\": []\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/:realm/authentication/flows/:flowAlias/executions') do |req|
  req.body = "{\n  \"alias\": \"\",\n  \"authenticationConfig\": \"\",\n  \"authenticationFlow\": false,\n  \"configurable\": false,\n  \"displayName\": \"\",\n  \"flowId\": \"\",\n  \"id\": \"\",\n  \"index\": 0,\n  \"level\": 0,\n  \"providerId\": \"\",\n  \"requirement\": \"\",\n  \"requirementChoices\": []\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions";

    let payload = json!({
        "alias": "",
        "authenticationConfig": "",
        "authenticationFlow": false,
        "configurable": false,
        "displayName": "",
        "flowId": "",
        "id": "",
        "index": 0,
        "level": 0,
        "providerId": "",
        "requirement": "",
        "requirementChoices": ()
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "alias": "",
  "authenticationConfig": "",
  "authenticationFlow": false,
  "configurable": false,
  "displayName": "",
  "flowId": "",
  "id": "",
  "index": 0,
  "level": 0,
  "providerId": "",
  "requirement": "",
  "requirementChoices": []
}' |  \
  http PUT {{baseUrl}}/:realm/authentication/flows/:flowAlias/executions \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "alias": "",\n  "authenticationConfig": "",\n  "authenticationFlow": false,\n  "configurable": false,\n  "displayName": "",\n  "flowId": "",\n  "id": "",\n  "index": 0,\n  "level": 0,\n  "providerId": "",\n  "requirement": "",\n  "requirementChoices": []\n}' \
  --output-document \
  - {{baseUrl}}/:realm/authentication/flows/:flowAlias/executions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "alias": "",
  "authenticationConfig": "",
  "authenticationFlow": false,
  "configurable": false,
  "displayName": "",
  "flowId": "",
  "id": "",
  "index": 0,
  "level": 0,
  "providerId": "",
  "requirement": "",
  "requirementChoices": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/authentication/flows/:flowAlias/executions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/:realm/authentication/config/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"alias\": \"\",\n  \"config\": {},\n  \"id\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/:realm/authentication/config/:id" {:content-type :json
                                                                            :form-params {:alias ""
                                                                                          :config {}
                                                                                          :id ""}})

require "http/client"

url = "{{baseUrl}}/:realm/authentication/config/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"alias\": \"\",\n  \"config\": {},\n  \"id\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/:realm/authentication/config/:id"),
    Content = new StringContent("{\n  \"alias\": \"\",\n  \"config\": {},\n  \"id\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/authentication/config/:id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"alias\": \"\",\n  \"config\": {},\n  \"id\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/:realm/authentication/config/:id"

	payload := strings.NewReader("{\n  \"alias\": \"\",\n  \"config\": {},\n  \"id\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/:realm/authentication/config/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 45

{
  "alias": "",
  "config": {},
  "id": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/:realm/authentication/config/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"alias\": \"\",\n  \"config\": {},\n  \"id\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/authentication/config/:id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"alias\": \"\",\n  \"config\": {},\n  \"id\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"alias\": \"\",\n  \"config\": {},\n  \"id\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/config/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/:realm/authentication/config/:id")
  .header("content-type", "application/json")
  .body("{\n  \"alias\": \"\",\n  \"config\": {},\n  \"id\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  alias: '',
  config: {},
  id: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/:realm/authentication/config/:id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/:realm/authentication/config/:id',
  headers: {'content-type': 'application/json'},
  data: {alias: '', config: {}, id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/:realm/authentication/config/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"alias":"","config":{},"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}}/:realm/authentication/config/:id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "alias": "",\n  "config": {},\n  "id": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"alias\": \"\",\n  \"config\": {},\n  \"id\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/config/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/authentication/config/:id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({alias: '', config: {}, id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/:realm/authentication/config/:id',
  headers: {'content-type': 'application/json'},
  body: {alias: '', config: {}, id: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/:realm/authentication/config/:id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  alias: '',
  config: {},
  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: 'PUT',
  url: '{{baseUrl}}/:realm/authentication/config/:id',
  headers: {'content-type': 'application/json'},
  data: {alias: '', config: {}, id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/:realm/authentication/config/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"alias":"","config":{},"id":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"alias": @"",
                              @"config": @{  },
                              @"id": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/:realm/authentication/config/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/:realm/authentication/config/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"alias\": \"\",\n  \"config\": {},\n  \"id\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/:realm/authentication/config/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'alias' => '',
    'config' => [
        
    ],
    'id' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/:realm/authentication/config/:id', [
  'body' => '{
  "alias": "",
  "config": {},
  "id": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/authentication/config/:id');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'alias' => '',
  'config' => [
    
  ],
  'id' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'alias' => '',
  'config' => [
    
  ],
  'id' => ''
]));
$request->setRequestUrl('{{baseUrl}}/:realm/authentication/config/:id');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/authentication/config/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "alias": "",
  "config": {},
  "id": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/authentication/config/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "alias": "",
  "config": {},
  "id": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"alias\": \"\",\n  \"config\": {},\n  \"id\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/:realm/authentication/config/:id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/:realm/authentication/config/:id"

payload = {
    "alias": "",
    "config": {},
    "id": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/authentication/config/:id"

payload <- "{\n  \"alias\": \"\",\n  \"config\": {},\n  \"id\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/authentication/config/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"alias\": \"\",\n  \"config\": {},\n  \"id\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/:realm/authentication/config/:id') do |req|
  req.body = "{\n  \"alias\": \"\",\n  \"config\": {},\n  \"id\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/authentication/config/:id";

    let payload = json!({
        "alias": "",
        "config": json!({}),
        "id": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "alias": "",
  "config": {},
  "id": ""
}' |  \
  http PUT {{baseUrl}}/:realm/authentication/config/:id \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "alias": "",\n  "config": {},\n  "id": ""\n}' \
  --output-document \
  - {{baseUrl}}/:realm/authentication/config/:id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "alias": "",
  "config": [],
  "id": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/authentication/config/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/:realm/authentication/executions/:executionId/config");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"alias\": \"\",\n  \"config\": {},\n  \"id\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/:realm/authentication/executions/:executionId/config" {:content-type :json
                                                                                                 :form-params {:alias ""
                                                                                                               :config {}
                                                                                                               :id ""}})

require "http/client"

url = "{{baseUrl}}/:realm/authentication/executions/:executionId/config"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"alias\": \"\",\n  \"config\": {},\n  \"id\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/:realm/authentication/executions/:executionId/config"),
    Content = new StringContent("{\n  \"alias\": \"\",\n  \"config\": {},\n  \"id\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/authentication/executions/:executionId/config");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"alias\": \"\",\n  \"config\": {},\n  \"id\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/:realm/authentication/executions/:executionId/config"

	payload := strings.NewReader("{\n  \"alias\": \"\",\n  \"config\": {},\n  \"id\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/:realm/authentication/executions/:executionId/config HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 45

{
  "alias": "",
  "config": {},
  "id": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/:realm/authentication/executions/:executionId/config")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"alias\": \"\",\n  \"config\": {},\n  \"id\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/authentication/executions/:executionId/config"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"alias\": \"\",\n  \"config\": {},\n  \"id\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"alias\": \"\",\n  \"config\": {},\n  \"id\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/executions/:executionId/config")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/:realm/authentication/executions/:executionId/config")
  .header("content-type", "application/json")
  .body("{\n  \"alias\": \"\",\n  \"config\": {},\n  \"id\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  alias: '',
  config: {},
  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}}/:realm/authentication/executions/:executionId/config');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/authentication/executions/:executionId/config',
  headers: {'content-type': 'application/json'},
  data: {alias: '', config: {}, id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/:realm/authentication/executions/:executionId/config';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"alias":"","config":{},"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}}/:realm/authentication/executions/:executionId/config',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "alias": "",\n  "config": {},\n  "id": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"alias\": \"\",\n  \"config\": {},\n  \"id\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/executions/:executionId/config")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/authentication/executions/:executionId/config',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({alias: '', config: {}, id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/authentication/executions/:executionId/config',
  headers: {'content-type': 'application/json'},
  body: {alias: '', config: {}, id: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/:realm/authentication/executions/:executionId/config');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  alias: '',
  config: {},
  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: 'POST',
  url: '{{baseUrl}}/:realm/authentication/executions/:executionId/config',
  headers: {'content-type': 'application/json'},
  data: {alias: '', config: {}, id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/:realm/authentication/executions/:executionId/config';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"alias":"","config":{},"id":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"alias": @"",
                              @"config": @{  },
                              @"id": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/:realm/authentication/executions/:executionId/config"]
                                                       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}}/:realm/authentication/executions/:executionId/config" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"alias\": \"\",\n  \"config\": {},\n  \"id\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/:realm/authentication/executions/:executionId/config",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'alias' => '',
    'config' => [
        
    ],
    'id' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/:realm/authentication/executions/:executionId/config', [
  'body' => '{
  "alias": "",
  "config": {},
  "id": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/authentication/executions/:executionId/config');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'alias' => '',
  'config' => [
    
  ],
  'id' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'alias' => '',
  'config' => [
    
  ],
  'id' => ''
]));
$request->setRequestUrl('{{baseUrl}}/:realm/authentication/executions/:executionId/config');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/authentication/executions/:executionId/config' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "alias": "",
  "config": {},
  "id": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/authentication/executions/:executionId/config' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "alias": "",
  "config": {},
  "id": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"alias\": \"\",\n  \"config\": {},\n  \"id\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/:realm/authentication/executions/:executionId/config", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/:realm/authentication/executions/:executionId/config"

payload = {
    "alias": "",
    "config": {},
    "id": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/authentication/executions/:executionId/config"

payload <- "{\n  \"alias\": \"\",\n  \"config\": {},\n  \"id\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/authentication/executions/:executionId/config")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"alias\": \"\",\n  \"config\": {},\n  \"id\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/:realm/authentication/executions/:executionId/config') do |req|
  req.body = "{\n  \"alias\": \"\",\n  \"config\": {},\n  \"id\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/authentication/executions/:executionId/config";

    let payload = json!({
        "alias": "",
        "config": json!({}),
        "id": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "alias": "",
  "config": {},
  "id": ""
}' |  \
  http POST {{baseUrl}}/:realm/authentication/executions/:executionId/config \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "alias": "",\n  "config": {},\n  "id": ""\n}' \
  --output-document \
  - {{baseUrl}}/:realm/authentication/executions/:executionId/config

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "alias": "",
  "config": [],
  "id": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/authentication/executions/:executionId/config")! 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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/:realm/authentication/required-actions/:alias");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"alias\": \"\",\n  \"config\": {},\n  \"defaultAction\": false,\n  \"enabled\": false,\n  \"name\": \"\",\n  \"priority\": 0,\n  \"providerId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/:realm/authentication/required-actions/:alias" {:content-type :json
                                                                                         :form-params {:alias ""
                                                                                                       :config {}
                                                                                                       :defaultAction false
                                                                                                       :enabled false
                                                                                                       :name ""
                                                                                                       :priority 0
                                                                                                       :providerId ""}})

require "http/client"

url = "{{baseUrl}}/:realm/authentication/required-actions/:alias"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"alias\": \"\",\n  \"config\": {},\n  \"defaultAction\": false,\n  \"enabled\": false,\n  \"name\": \"\",\n  \"priority\": 0,\n  \"providerId\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/:realm/authentication/required-actions/:alias"),
    Content = new StringContent("{\n  \"alias\": \"\",\n  \"config\": {},\n  \"defaultAction\": false,\n  \"enabled\": false,\n  \"name\": \"\",\n  \"priority\": 0,\n  \"providerId\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/authentication/required-actions/:alias");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"alias\": \"\",\n  \"config\": {},\n  \"defaultAction\": false,\n  \"enabled\": false,\n  \"name\": \"\",\n  \"priority\": 0,\n  \"providerId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/:realm/authentication/required-actions/:alias"

	payload := strings.NewReader("{\n  \"alias\": \"\",\n  \"config\": {},\n  \"defaultAction\": false,\n  \"enabled\": false,\n  \"name\": \"\",\n  \"priority\": 0,\n  \"providerId\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/:realm/authentication/required-actions/:alias HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 130

{
  "alias": "",
  "config": {},
  "defaultAction": false,
  "enabled": false,
  "name": "",
  "priority": 0,
  "providerId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/:realm/authentication/required-actions/:alias")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"alias\": \"\",\n  \"config\": {},\n  \"defaultAction\": false,\n  \"enabled\": false,\n  \"name\": \"\",\n  \"priority\": 0,\n  \"providerId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/authentication/required-actions/:alias"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"alias\": \"\",\n  \"config\": {},\n  \"defaultAction\": false,\n  \"enabled\": false,\n  \"name\": \"\",\n  \"priority\": 0,\n  \"providerId\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"alias\": \"\",\n  \"config\": {},\n  \"defaultAction\": false,\n  \"enabled\": false,\n  \"name\": \"\",\n  \"priority\": 0,\n  \"providerId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/required-actions/:alias")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/:realm/authentication/required-actions/:alias")
  .header("content-type", "application/json")
  .body("{\n  \"alias\": \"\",\n  \"config\": {},\n  \"defaultAction\": false,\n  \"enabled\": false,\n  \"name\": \"\",\n  \"priority\": 0,\n  \"providerId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  alias: '',
  config: {},
  defaultAction: false,
  enabled: false,
  name: '',
  priority: 0,
  providerId: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/:realm/authentication/required-actions/:alias');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/:realm/authentication/required-actions/:alias',
  headers: {'content-type': 'application/json'},
  data: {
    alias: '',
    config: {},
    defaultAction: false,
    enabled: false,
    name: '',
    priority: 0,
    providerId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/:realm/authentication/required-actions/:alias';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"alias":"","config":{},"defaultAction":false,"enabled":false,"name":"","priority":0,"providerId":""}'
};

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}}/:realm/authentication/required-actions/:alias',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "alias": "",\n  "config": {},\n  "defaultAction": false,\n  "enabled": false,\n  "name": "",\n  "priority": 0,\n  "providerId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"alias\": \"\",\n  \"config\": {},\n  \"defaultAction\": false,\n  \"enabled\": false,\n  \"name\": \"\",\n  \"priority\": 0,\n  \"providerId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/:realm/authentication/required-actions/:alias")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/authentication/required-actions/:alias',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  alias: '',
  config: {},
  defaultAction: false,
  enabled: false,
  name: '',
  priority: 0,
  providerId: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/:realm/authentication/required-actions/:alias',
  headers: {'content-type': 'application/json'},
  body: {
    alias: '',
    config: {},
    defaultAction: false,
    enabled: false,
    name: '',
    priority: 0,
    providerId: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/:realm/authentication/required-actions/:alias');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  alias: '',
  config: {},
  defaultAction: false,
  enabled: false,
  name: '',
  priority: 0,
  providerId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/:realm/authentication/required-actions/:alias',
  headers: {'content-type': 'application/json'},
  data: {
    alias: '',
    config: {},
    defaultAction: false,
    enabled: false,
    name: '',
    priority: 0,
    providerId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/:realm/authentication/required-actions/:alias';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"alias":"","config":{},"defaultAction":false,"enabled":false,"name":"","priority":0,"providerId":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"alias": @"",
                              @"config": @{  },
                              @"defaultAction": @NO,
                              @"enabled": @NO,
                              @"name": @"",
                              @"priority": @0,
                              @"providerId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/:realm/authentication/required-actions/:alias"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/:realm/authentication/required-actions/:alias" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"alias\": \"\",\n  \"config\": {},\n  \"defaultAction\": false,\n  \"enabled\": false,\n  \"name\": \"\",\n  \"priority\": 0,\n  \"providerId\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/:realm/authentication/required-actions/:alias",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'alias' => '',
    'config' => [
        
    ],
    'defaultAction' => null,
    'enabled' => null,
    'name' => '',
    'priority' => 0,
    'providerId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/:realm/authentication/required-actions/:alias', [
  'body' => '{
  "alias": "",
  "config": {},
  "defaultAction": false,
  "enabled": false,
  "name": "",
  "priority": 0,
  "providerId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/authentication/required-actions/:alias');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'alias' => '',
  'config' => [
    
  ],
  'defaultAction' => null,
  'enabled' => null,
  'name' => '',
  'priority' => 0,
  'providerId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'alias' => '',
  'config' => [
    
  ],
  'defaultAction' => null,
  'enabled' => null,
  'name' => '',
  'priority' => 0,
  'providerId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/:realm/authentication/required-actions/:alias');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/authentication/required-actions/:alias' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "alias": "",
  "config": {},
  "defaultAction": false,
  "enabled": false,
  "name": "",
  "priority": 0,
  "providerId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/authentication/required-actions/:alias' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "alias": "",
  "config": {},
  "defaultAction": false,
  "enabled": false,
  "name": "",
  "priority": 0,
  "providerId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"alias\": \"\",\n  \"config\": {},\n  \"defaultAction\": false,\n  \"enabled\": false,\n  \"name\": \"\",\n  \"priority\": 0,\n  \"providerId\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/:realm/authentication/required-actions/:alias", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/:realm/authentication/required-actions/:alias"

payload = {
    "alias": "",
    "config": {},
    "defaultAction": False,
    "enabled": False,
    "name": "",
    "priority": 0,
    "providerId": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/authentication/required-actions/:alias"

payload <- "{\n  \"alias\": \"\",\n  \"config\": {},\n  \"defaultAction\": false,\n  \"enabled\": false,\n  \"name\": \"\",\n  \"priority\": 0,\n  \"providerId\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/authentication/required-actions/:alias")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"alias\": \"\",\n  \"config\": {},\n  \"defaultAction\": false,\n  \"enabled\": false,\n  \"name\": \"\",\n  \"priority\": 0,\n  \"providerId\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/:realm/authentication/required-actions/:alias') do |req|
  req.body = "{\n  \"alias\": \"\",\n  \"config\": {},\n  \"defaultAction\": false,\n  \"enabled\": false,\n  \"name\": \"\",\n  \"priority\": 0,\n  \"providerId\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/authentication/required-actions/:alias";

    let payload = json!({
        "alias": "",
        "config": json!({}),
        "defaultAction": false,
        "enabled": false,
        "name": "",
        "priority": 0,
        "providerId": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "alias": "",
  "config": {},
  "defaultAction": false,
  "enabled": false,
  "name": "",
  "priority": 0,
  "providerId": ""
}' |  \
  http PUT {{baseUrl}}/:realm/authentication/required-actions/:alias \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "alias": "",\n  "config": {},\n  "defaultAction": false,\n  "enabled": false,\n  "name": "",\n  "priority": 0,\n  "providerId": ""\n}' \
  --output-document \
  - {{baseUrl}}/:realm/authentication/required-actions/:alias

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "alias": "",
  "config": [],
  "defaultAction": false,
  "enabled": false,
  "name": "",
  "priority": 0,
  "providerId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/authentication/required-actions/:alias")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate")

require "http/client"

url = "{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/:realm/clients/:id/certificates/:attr/generate HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/clients/:id/certificates/:attr/generate',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/:realm/clients/:id/certificates/:attr/generate")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/:realm/clients/:id/certificates/:attr/generate') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/:realm/clients/:id/certificates/:attr/generate

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/:realm/clients/:id/certificates/:attr/generate

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate-and-download");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"format\": \"\",\n  \"keyAlias\": \"\",\n  \"keyPassword\": \"\",\n  \"realmAlias\": \"\",\n  \"realmCertificate\": false,\n  \"storePassword\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate-and-download" {:content-type :json
                                                                                                        :form-params {:format ""
                                                                                                                      :keyAlias ""
                                                                                                                      :keyPassword ""
                                                                                                                      :realmAlias ""
                                                                                                                      :realmCertificate false
                                                                                                                      :storePassword ""}})

require "http/client"

url = "{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate-and-download"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"format\": \"\",\n  \"keyAlias\": \"\",\n  \"keyPassword\": \"\",\n  \"realmAlias\": \"\",\n  \"realmCertificate\": false,\n  \"storePassword\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate-and-download"),
    Content = new StringContent("{\n  \"format\": \"\",\n  \"keyAlias\": \"\",\n  \"keyPassword\": \"\",\n  \"realmAlias\": \"\",\n  \"realmCertificate\": false,\n  \"storePassword\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate-and-download");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"format\": \"\",\n  \"keyAlias\": \"\",\n  \"keyPassword\": \"\",\n  \"realmAlias\": \"\",\n  \"realmCertificate\": false,\n  \"storePassword\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate-and-download"

	payload := strings.NewReader("{\n  \"format\": \"\",\n  \"keyAlias\": \"\",\n  \"keyPassword\": \"\",\n  \"realmAlias\": \"\",\n  \"realmCertificate\": false,\n  \"storePassword\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/:realm/clients/:id/certificates/:attr/generate-and-download HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 129

{
  "format": "",
  "keyAlias": "",
  "keyPassword": "",
  "realmAlias": "",
  "realmCertificate": false,
  "storePassword": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate-and-download")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"format\": \"\",\n  \"keyAlias\": \"\",\n  \"keyPassword\": \"\",\n  \"realmAlias\": \"\",\n  \"realmCertificate\": false,\n  \"storePassword\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate-and-download"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"format\": \"\",\n  \"keyAlias\": \"\",\n  \"keyPassword\": \"\",\n  \"realmAlias\": \"\",\n  \"realmCertificate\": false,\n  \"storePassword\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"format\": \"\",\n  \"keyAlias\": \"\",\n  \"keyPassword\": \"\",\n  \"realmAlias\": \"\",\n  \"realmCertificate\": false,\n  \"storePassword\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate-and-download")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate-and-download")
  .header("content-type", "application/json")
  .body("{\n  \"format\": \"\",\n  \"keyAlias\": \"\",\n  \"keyPassword\": \"\",\n  \"realmAlias\": \"\",\n  \"realmCertificate\": false,\n  \"storePassword\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  format: '',
  keyAlias: '',
  keyPassword: '',
  realmAlias: '',
  realmCertificate: false,
  storePassword: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate-and-download');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate-and-download',
  headers: {'content-type': 'application/json'},
  data: {
    format: '',
    keyAlias: '',
    keyPassword: '',
    realmAlias: '',
    realmCertificate: false,
    storePassword: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate-and-download';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"format":"","keyAlias":"","keyPassword":"","realmAlias":"","realmCertificate":false,"storePassword":""}'
};

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}}/:realm/clients/:id/certificates/:attr/generate-and-download',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "format": "",\n  "keyAlias": "",\n  "keyPassword": "",\n  "realmAlias": "",\n  "realmCertificate": false,\n  "storePassword": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"format\": \"\",\n  \"keyAlias\": \"\",\n  \"keyPassword\": \"\",\n  \"realmAlias\": \"\",\n  \"realmCertificate\": false,\n  \"storePassword\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate-and-download")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/clients/:id/certificates/:attr/generate-and-download',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  format: '',
  keyAlias: '',
  keyPassword: '',
  realmAlias: '',
  realmCertificate: false,
  storePassword: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate-and-download',
  headers: {'content-type': 'application/json'},
  body: {
    format: '',
    keyAlias: '',
    keyPassword: '',
    realmAlias: '',
    realmCertificate: false,
    storePassword: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate-and-download');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  format: '',
  keyAlias: '',
  keyPassword: '',
  realmAlias: '',
  realmCertificate: false,
  storePassword: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate-and-download',
  headers: {'content-type': 'application/json'},
  data: {
    format: '',
    keyAlias: '',
    keyPassword: '',
    realmAlias: '',
    realmCertificate: false,
    storePassword: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate-and-download';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"format":"","keyAlias":"","keyPassword":"","realmAlias":"","realmCertificate":false,"storePassword":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"format": @"",
                              @"keyAlias": @"",
                              @"keyPassword": @"",
                              @"realmAlias": @"",
                              @"realmCertificate": @NO,
                              @"storePassword": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate-and-download"]
                                                       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}}/:realm/clients/:id/certificates/:attr/generate-and-download" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"format\": \"\",\n  \"keyAlias\": \"\",\n  \"keyPassword\": \"\",\n  \"realmAlias\": \"\",\n  \"realmCertificate\": false,\n  \"storePassword\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate-and-download",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'format' => '',
    'keyAlias' => '',
    'keyPassword' => '',
    'realmAlias' => '',
    'realmCertificate' => null,
    'storePassword' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate-and-download', [
  'body' => '{
  "format": "",
  "keyAlias": "",
  "keyPassword": "",
  "realmAlias": "",
  "realmCertificate": false,
  "storePassword": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate-and-download');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'format' => '',
  'keyAlias' => '',
  'keyPassword' => '',
  'realmAlias' => '',
  'realmCertificate' => null,
  'storePassword' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'format' => '',
  'keyAlias' => '',
  'keyPassword' => '',
  'realmAlias' => '',
  'realmCertificate' => null,
  'storePassword' => ''
]));
$request->setRequestUrl('{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate-and-download');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate-and-download' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "format": "",
  "keyAlias": "",
  "keyPassword": "",
  "realmAlias": "",
  "realmCertificate": false,
  "storePassword": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate-and-download' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "format": "",
  "keyAlias": "",
  "keyPassword": "",
  "realmAlias": "",
  "realmCertificate": false,
  "storePassword": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"format\": \"\",\n  \"keyAlias\": \"\",\n  \"keyPassword\": \"\",\n  \"realmAlias\": \"\",\n  \"realmCertificate\": false,\n  \"storePassword\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/:realm/clients/:id/certificates/:attr/generate-and-download", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate-and-download"

payload = {
    "format": "",
    "keyAlias": "",
    "keyPassword": "",
    "realmAlias": "",
    "realmCertificate": False,
    "storePassword": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate-and-download"

payload <- "{\n  \"format\": \"\",\n  \"keyAlias\": \"\",\n  \"keyPassword\": \"\",\n  \"realmAlias\": \"\",\n  \"realmCertificate\": false,\n  \"storePassword\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate-and-download")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"format\": \"\",\n  \"keyAlias\": \"\",\n  \"keyPassword\": \"\",\n  \"realmAlias\": \"\",\n  \"realmCertificate\": false,\n  \"storePassword\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/:realm/clients/:id/certificates/:attr/generate-and-download') do |req|
  req.body = "{\n  \"format\": \"\",\n  \"keyAlias\": \"\",\n  \"keyPassword\": \"\",\n  \"realmAlias\": \"\",\n  \"realmCertificate\": false,\n  \"storePassword\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate-and-download";

    let payload = json!({
        "format": "",
        "keyAlias": "",
        "keyPassword": "",
        "realmAlias": "",
        "realmCertificate": false,
        "storePassword": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "format": "",
  "keyAlias": "",
  "keyPassword": "",
  "realmAlias": "",
  "realmCertificate": false,
  "storePassword": ""
}' |  \
  http POST {{baseUrl}}/:realm/clients/:id/certificates/:attr/generate-and-download \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "format": "",\n  "keyAlias": "",\n  "keyPassword": "",\n  "realmAlias": "",\n  "realmCertificate": false,\n  "storePassword": ""\n}' \
  --output-document \
  - {{baseUrl}}/:realm/clients/:id/certificates/:attr/generate-and-download

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "format": "",
  "keyAlias": "",
  "keyPassword": "",
  "realmAlias": "",
  "realmCertificate": false,
  "storePassword": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/clients/:id/certificates/:attr/generate-and-download")! 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}}/:realm/clients/:id/certificates/:attr/download");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"format\": \"\",\n  \"keyAlias\": \"\",\n  \"keyPassword\": \"\",\n  \"realmAlias\": \"\",\n  \"realmCertificate\": false,\n  \"storePassword\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/:realm/clients/:id/certificates/:attr/download" {:content-type :json
                                                                                           :form-params {:format ""
                                                                                                         :keyAlias ""
                                                                                                         :keyPassword ""
                                                                                                         :realmAlias ""
                                                                                                         :realmCertificate false
                                                                                                         :storePassword ""}})

require "http/client"

url = "{{baseUrl}}/:realm/clients/:id/certificates/:attr/download"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"format\": \"\",\n  \"keyAlias\": \"\",\n  \"keyPassword\": \"\",\n  \"realmAlias\": \"\",\n  \"realmCertificate\": false,\n  \"storePassword\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/:realm/clients/:id/certificates/:attr/download"),
    Content = new StringContent("{\n  \"format\": \"\",\n  \"keyAlias\": \"\",\n  \"keyPassword\": \"\",\n  \"realmAlias\": \"\",\n  \"realmCertificate\": false,\n  \"storePassword\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/clients/:id/certificates/:attr/download");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"format\": \"\",\n  \"keyAlias\": \"\",\n  \"keyPassword\": \"\",\n  \"realmAlias\": \"\",\n  \"realmCertificate\": false,\n  \"storePassword\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/:realm/clients/:id/certificates/:attr/download"

	payload := strings.NewReader("{\n  \"format\": \"\",\n  \"keyAlias\": \"\",\n  \"keyPassword\": \"\",\n  \"realmAlias\": \"\",\n  \"realmCertificate\": false,\n  \"storePassword\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/:realm/clients/:id/certificates/:attr/download HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 129

{
  "format": "",
  "keyAlias": "",
  "keyPassword": "",
  "realmAlias": "",
  "realmCertificate": false,
  "storePassword": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/:realm/clients/:id/certificates/:attr/download")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"format\": \"\",\n  \"keyAlias\": \"\",\n  \"keyPassword\": \"\",\n  \"realmAlias\": \"\",\n  \"realmCertificate\": false,\n  \"storePassword\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/clients/:id/certificates/:attr/download"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"format\": \"\",\n  \"keyAlias\": \"\",\n  \"keyPassword\": \"\",\n  \"realmAlias\": \"\",\n  \"realmCertificate\": false,\n  \"storePassword\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"format\": \"\",\n  \"keyAlias\": \"\",\n  \"keyPassword\": \"\",\n  \"realmAlias\": \"\",\n  \"realmCertificate\": false,\n  \"storePassword\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/:realm/clients/:id/certificates/:attr/download")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/:realm/clients/:id/certificates/:attr/download")
  .header("content-type", "application/json")
  .body("{\n  \"format\": \"\",\n  \"keyAlias\": \"\",\n  \"keyPassword\": \"\",\n  \"realmAlias\": \"\",\n  \"realmCertificate\": false,\n  \"storePassword\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  format: '',
  keyAlias: '',
  keyPassword: '',
  realmAlias: '',
  realmCertificate: false,
  storePassword: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/:realm/clients/:id/certificates/:attr/download');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/clients/:id/certificates/:attr/download',
  headers: {'content-type': 'application/json'},
  data: {
    format: '',
    keyAlias: '',
    keyPassword: '',
    realmAlias: '',
    realmCertificate: false,
    storePassword: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/:realm/clients/:id/certificates/:attr/download';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"format":"","keyAlias":"","keyPassword":"","realmAlias":"","realmCertificate":false,"storePassword":""}'
};

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}}/:realm/clients/:id/certificates/:attr/download',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "format": "",\n  "keyAlias": "",\n  "keyPassword": "",\n  "realmAlias": "",\n  "realmCertificate": false,\n  "storePassword": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"format\": \"\",\n  \"keyAlias\": \"\",\n  \"keyPassword\": \"\",\n  \"realmAlias\": \"\",\n  \"realmCertificate\": false,\n  \"storePassword\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/:realm/clients/:id/certificates/:attr/download")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/clients/:id/certificates/:attr/download',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  format: '',
  keyAlias: '',
  keyPassword: '',
  realmAlias: '',
  realmCertificate: false,
  storePassword: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/clients/:id/certificates/:attr/download',
  headers: {'content-type': 'application/json'},
  body: {
    format: '',
    keyAlias: '',
    keyPassword: '',
    realmAlias: '',
    realmCertificate: false,
    storePassword: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/:realm/clients/:id/certificates/:attr/download');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  format: '',
  keyAlias: '',
  keyPassword: '',
  realmAlias: '',
  realmCertificate: false,
  storePassword: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/clients/:id/certificates/:attr/download',
  headers: {'content-type': 'application/json'},
  data: {
    format: '',
    keyAlias: '',
    keyPassword: '',
    realmAlias: '',
    realmCertificate: false,
    storePassword: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/:realm/clients/:id/certificates/:attr/download';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"format":"","keyAlias":"","keyPassword":"","realmAlias":"","realmCertificate":false,"storePassword":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"format": @"",
                              @"keyAlias": @"",
                              @"keyPassword": @"",
                              @"realmAlias": @"",
                              @"realmCertificate": @NO,
                              @"storePassword": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/:realm/clients/:id/certificates/:attr/download"]
                                                       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}}/:realm/clients/:id/certificates/:attr/download" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"format\": \"\",\n  \"keyAlias\": \"\",\n  \"keyPassword\": \"\",\n  \"realmAlias\": \"\",\n  \"realmCertificate\": false,\n  \"storePassword\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/:realm/clients/:id/certificates/:attr/download",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'format' => '',
    'keyAlias' => '',
    'keyPassword' => '',
    'realmAlias' => '',
    'realmCertificate' => null,
    'storePassword' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/:realm/clients/:id/certificates/:attr/download', [
  'body' => '{
  "format": "",
  "keyAlias": "",
  "keyPassword": "",
  "realmAlias": "",
  "realmCertificate": false,
  "storePassword": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/clients/:id/certificates/:attr/download');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'format' => '',
  'keyAlias' => '',
  'keyPassword' => '',
  'realmAlias' => '',
  'realmCertificate' => null,
  'storePassword' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'format' => '',
  'keyAlias' => '',
  'keyPassword' => '',
  'realmAlias' => '',
  'realmCertificate' => null,
  'storePassword' => ''
]));
$request->setRequestUrl('{{baseUrl}}/:realm/clients/:id/certificates/:attr/download');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/clients/:id/certificates/:attr/download' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "format": "",
  "keyAlias": "",
  "keyPassword": "",
  "realmAlias": "",
  "realmCertificate": false,
  "storePassword": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/clients/:id/certificates/:attr/download' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "format": "",
  "keyAlias": "",
  "keyPassword": "",
  "realmAlias": "",
  "realmCertificate": false,
  "storePassword": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"format\": \"\",\n  \"keyAlias\": \"\",\n  \"keyPassword\": \"\",\n  \"realmAlias\": \"\",\n  \"realmCertificate\": false,\n  \"storePassword\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/:realm/clients/:id/certificates/:attr/download", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/:realm/clients/:id/certificates/:attr/download"

payload = {
    "format": "",
    "keyAlias": "",
    "keyPassword": "",
    "realmAlias": "",
    "realmCertificate": False,
    "storePassword": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/clients/:id/certificates/:attr/download"

payload <- "{\n  \"format\": \"\",\n  \"keyAlias\": \"\",\n  \"keyPassword\": \"\",\n  \"realmAlias\": \"\",\n  \"realmCertificate\": false,\n  \"storePassword\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/clients/:id/certificates/:attr/download")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"format\": \"\",\n  \"keyAlias\": \"\",\n  \"keyPassword\": \"\",\n  \"realmAlias\": \"\",\n  \"realmCertificate\": false,\n  \"storePassword\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/:realm/clients/:id/certificates/:attr/download') do |req|
  req.body = "{\n  \"format\": \"\",\n  \"keyAlias\": \"\",\n  \"keyPassword\": \"\",\n  \"realmAlias\": \"\",\n  \"realmCertificate\": false,\n  \"storePassword\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/clients/:id/certificates/:attr/download";

    let payload = json!({
        "format": "",
        "keyAlias": "",
        "keyPassword": "",
        "realmAlias": "",
        "realmCertificate": false,
        "storePassword": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "format": "",
  "keyAlias": "",
  "keyPassword": "",
  "realmAlias": "",
  "realmCertificate": false,
  "storePassword": ""
}' |  \
  http POST {{baseUrl}}/:realm/clients/:id/certificates/:attr/download \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "format": "",\n  "keyAlias": "",\n  "keyPassword": "",\n  "realmAlias": "",\n  "realmCertificate": false,\n  "storePassword": ""\n}' \
  --output-document \
  - {{baseUrl}}/:realm/clients/:id/certificates/:attr/download

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "format": "",
  "keyAlias": "",
  "keyPassword": "",
  "realmAlias": "",
  "realmCertificate": false,
  "storePassword": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/clients/:id/certificates/:attr/download")! 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}}/:realm/clients/:id/certificates/:attr");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/:realm/clients/:id/certificates/:attr")

require "http/client"

url = "{{baseUrl}}/:realm/clients/:id/certificates/:attr"

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}}/:realm/clients/:id/certificates/:attr"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/clients/:id/certificates/:attr");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/:realm/clients/:id/certificates/:attr"

	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/:realm/clients/:id/certificates/:attr HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/:realm/clients/:id/certificates/:attr")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/clients/:id/certificates/:attr"))
    .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}}/:realm/clients/:id/certificates/:attr")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/:realm/clients/:id/certificates/:attr")
  .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}}/:realm/clients/:id/certificates/:attr');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/:realm/clients/:id/certificates/:attr'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/:realm/clients/:id/certificates/:attr';
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}}/:realm/clients/:id/certificates/:attr',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/clients/:id/certificates/:attr")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/clients/:id/certificates/:attr',
  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}}/:realm/clients/:id/certificates/:attr'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/:realm/clients/:id/certificates/:attr');

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}}/:realm/clients/:id/certificates/:attr'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/:realm/clients/:id/certificates/:attr';
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}}/:realm/clients/:id/certificates/:attr"]
                                                       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}}/:realm/clients/:id/certificates/:attr" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/:realm/clients/:id/certificates/:attr",
  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}}/:realm/clients/:id/certificates/:attr');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/clients/:id/certificates/:attr');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/:realm/clients/:id/certificates/:attr');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/clients/:id/certificates/:attr' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/clients/:id/certificates/:attr' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/:realm/clients/:id/certificates/:attr")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/:realm/clients/:id/certificates/:attr"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/clients/:id/certificates/:attr"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/clients/:id/certificates/:attr")

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/:realm/clients/:id/certificates/:attr') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/clients/:id/certificates/:attr";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/:realm/clients/:id/certificates/:attr

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/:realm/clients/:id/certificates/:attr

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/clients/:id/certificates/:attr")! 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}}/:realm/clients/:id/certificates/:attr/upload");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload")

require "http/client"

url = "{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/:realm/clients/:id/certificates/:attr/upload HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/clients/:id/certificates/:attr/upload',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/:realm/clients/:id/certificates/:attr/upload")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/:realm/clients/:id/certificates/:attr/upload') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/:realm/clients/:id/certificates/:attr/upload

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/:realm/clients/:id/certificates/:attr/upload

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload-certificate");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload-certificate")

require "http/client"

url = "{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload-certificate"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload-certificate"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload-certificate");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload-certificate"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/:realm/clients/:id/certificates/:attr/upload-certificate HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload-certificate")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload-certificate"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload-certificate")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload-certificate")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload-certificate');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload-certificate'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload-certificate';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload-certificate',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload-certificate")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/clients/:id/certificates/:attr/upload-certificate',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload-certificate'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload-certificate');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload-certificate'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload-certificate';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload-certificate"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload-certificate" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload-certificate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload-certificate');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload-certificate');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload-certificate');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload-certificate' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload-certificate' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/:realm/clients/:id/certificates/:attr/upload-certificate")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload-certificate"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload-certificate"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload-certificate")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/:realm/clients/:id/certificates/:attr/upload-certificate') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload-certificate";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/:realm/clients/:id/certificates/:attr/upload-certificate

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/:realm/clients/:id/certificates/:attr/upload-certificate

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/clients/:id/certificates/:attr/upload-certificate")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/:realm/clients-initial-access");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"count\": 0,\n  \"expiration\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/:realm/clients-initial-access" {:content-type :json
                                                                          :form-params {:count 0
                                                                                        :expiration 0}})

require "http/client"

url = "{{baseUrl}}/:realm/clients-initial-access"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"count\": 0,\n  \"expiration\": 0\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/:realm/clients-initial-access"),
    Content = new StringContent("{\n  \"count\": 0,\n  \"expiration\": 0\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/clients-initial-access");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"count\": 0,\n  \"expiration\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/:realm/clients-initial-access"

	payload := strings.NewReader("{\n  \"count\": 0,\n  \"expiration\": 0\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/:realm/clients-initial-access HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 35

{
  "count": 0,
  "expiration": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/:realm/clients-initial-access")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"count\": 0,\n  \"expiration\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/clients-initial-access"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"count\": 0,\n  \"expiration\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"count\": 0,\n  \"expiration\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/:realm/clients-initial-access")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/:realm/clients-initial-access")
  .header("content-type", "application/json")
  .body("{\n  \"count\": 0,\n  \"expiration\": 0\n}")
  .asString();

const data = JSON.stringify({
  count: 0,
  expiration: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/:realm/clients-initial-access');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/clients-initial-access',
  headers: {'content-type': 'application/json'},
  data: {count: 0, expiration: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/:realm/clients-initial-access';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"count":0,"expiration":0}'
};

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}}/:realm/clients-initial-access',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "count": 0,\n  "expiration": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"count\": 0,\n  \"expiration\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/:realm/clients-initial-access")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/clients-initial-access',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({count: 0, expiration: 0}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/clients-initial-access',
  headers: {'content-type': 'application/json'},
  body: {count: 0, expiration: 0},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/:realm/clients-initial-access');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  count: 0,
  expiration: 0
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/clients-initial-access',
  headers: {'content-type': 'application/json'},
  data: {count: 0, expiration: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/:realm/clients-initial-access';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"count":0,"expiration":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"count": @0,
                              @"expiration": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/:realm/clients-initial-access"]
                                                       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}}/:realm/clients-initial-access" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"count\": 0,\n  \"expiration\": 0\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/:realm/clients-initial-access",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'count' => 0,
    'expiration' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/:realm/clients-initial-access', [
  'body' => '{
  "count": 0,
  "expiration": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/clients-initial-access');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'count' => 0,
  'expiration' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'count' => 0,
  'expiration' => 0
]));
$request->setRequestUrl('{{baseUrl}}/:realm/clients-initial-access');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/clients-initial-access' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "count": 0,
  "expiration": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/clients-initial-access' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "count": 0,
  "expiration": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"count\": 0,\n  \"expiration\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/:realm/clients-initial-access", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/:realm/clients-initial-access"

payload = {
    "count": 0,
    "expiration": 0
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/clients-initial-access"

payload <- "{\n  \"count\": 0,\n  \"expiration\": 0\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/clients-initial-access")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"count\": 0,\n  \"expiration\": 0\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/:realm/clients-initial-access') do |req|
  req.body = "{\n  \"count\": 0,\n  \"expiration\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/clients-initial-access";

    let payload = json!({
        "count": 0,
        "expiration": 0
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "count": 0,
  "expiration": 0
}' |  \
  http POST {{baseUrl}}/:realm/clients-initial-access \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "count": 0,\n  "expiration": 0\n}' \
  --output-document \
  - {{baseUrl}}/:realm/clients-initial-access

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "count": 0,
  "expiration": 0
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/clients-initial-access")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/:realm/clients-initial-access/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/:realm/clients-initial-access/:id")

require "http/client"

url = "{{baseUrl}}/:realm/clients-initial-access/:id"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/:realm/clients-initial-access/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/clients-initial-access/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/:realm/clients-initial-access/:id"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/:realm/clients-initial-access/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/:realm/clients-initial-access/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/clients-initial-access/:id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/:realm/clients-initial-access/:id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/:realm/clients-initial-access/:id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/:realm/clients-initial-access/:id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/:realm/clients-initial-access/:id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/:realm/clients-initial-access/:id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/:realm/clients-initial-access/:id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/clients-initial-access/:id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/clients-initial-access/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/:realm/clients-initial-access/:id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/:realm/clients-initial-access/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/:realm/clients-initial-access/:id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/:realm/clients-initial-access/:id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/:realm/clients-initial-access/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/:realm/clients-initial-access/:id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/:realm/clients-initial-access/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/:realm/clients-initial-access/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/clients-initial-access/:id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/:realm/clients-initial-access/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/clients-initial-access/:id' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/clients-initial-access/:id' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/:realm/clients-initial-access/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/:realm/clients-initial-access/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/clients-initial-access/:id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/clients-initial-access/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/:realm/clients-initial-access/:id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/clients-initial-access/:id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/:realm/clients-initial-access/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/:realm/clients-initial-access/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/clients-initial-access/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/:realm/clients-initial-access");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/:realm/clients-initial-access")

require "http/client"

url = "{{baseUrl}}/:realm/clients-initial-access"

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}}/:realm/clients-initial-access"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/clients-initial-access");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/:realm/clients-initial-access"

	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/:realm/clients-initial-access HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/:realm/clients-initial-access")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/clients-initial-access"))
    .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}}/:realm/clients-initial-access")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/:realm/clients-initial-access")
  .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}}/:realm/clients-initial-access');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/:realm/clients-initial-access'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/:realm/clients-initial-access';
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}}/:realm/clients-initial-access',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/clients-initial-access")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/clients-initial-access',
  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}}/:realm/clients-initial-access'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/:realm/clients-initial-access');

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}}/:realm/clients-initial-access'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/:realm/clients-initial-access';
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}}/:realm/clients-initial-access"]
                                                       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}}/:realm/clients-initial-access" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/:realm/clients-initial-access",
  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}}/:realm/clients-initial-access');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/clients-initial-access');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/:realm/clients-initial-access');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/clients-initial-access' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/clients-initial-access' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/:realm/clients-initial-access")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/:realm/clients-initial-access"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/clients-initial-access"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/clients-initial-access")

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/:realm/clients-initial-access') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/clients-initial-access";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/:realm/clients-initial-access

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/:realm/clients-initial-access

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/clients-initial-access")! 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}}/:realm/client-registration-policy/providers");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/:realm/client-registration-policy/providers")

require "http/client"

url = "{{baseUrl}}/:realm/client-registration-policy/providers"

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}}/:realm/client-registration-policy/providers"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/client-registration-policy/providers");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/:realm/client-registration-policy/providers"

	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/:realm/client-registration-policy/providers HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/:realm/client-registration-policy/providers")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/client-registration-policy/providers"))
    .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}}/:realm/client-registration-policy/providers")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/:realm/client-registration-policy/providers")
  .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}}/:realm/client-registration-policy/providers');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/:realm/client-registration-policy/providers'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/:realm/client-registration-policy/providers';
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}}/:realm/client-registration-policy/providers',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/client-registration-policy/providers")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/client-registration-policy/providers',
  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}}/:realm/client-registration-policy/providers'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/:realm/client-registration-policy/providers');

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}}/:realm/client-registration-policy/providers'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/:realm/client-registration-policy/providers';
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}}/:realm/client-registration-policy/providers"]
                                                       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}}/:realm/client-registration-policy/providers" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/:realm/client-registration-policy/providers",
  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}}/:realm/client-registration-policy/providers');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/client-registration-policy/providers');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/:realm/client-registration-policy/providers');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/client-registration-policy/providers' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/client-registration-policy/providers' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/:realm/client-registration-policy/providers")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/:realm/client-registration-policy/providers"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/client-registration-policy/providers"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/client-registration-policy/providers")

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/:realm/client-registration-policy/providers') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/client-registration-policy/providers";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/:realm/client-registration-policy/providers

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/:realm/client-registration-policy/providers

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/client-registration-policy/providers")! 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}}/:realm/users/:id/role-mappings/clients/:client");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client" {:content-type :json
                                                                                           :form-params [{:attributes {}
                                                                                                          :clientRole false
                                                                                                          :composite false
                                                                                                          :composites {:client {}
                                                                                                                       :realm []}
                                                                                                          :containerId ""
                                                                                                          :description ""
                                                                                                          :id ""
                                                                                                          :name ""}]})

require "http/client"

url = "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client"),
    Content = new StringContent("[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client"

	payload := strings.NewReader("[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/:realm/users/:id/role-mappings/clients/:client HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 222

[
  {
    "attributes": {},
    "clientRole": false,
    "composite": false,
    "composites": {
      "client": {},
      "realm": []
    },
    "containerId": "",
    "description": "",
    "id": "",
    "name": ""
  }
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client")
  .header("content-type", "application/json")
  .body("[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]")
  .asString();

const data = JSON.stringify([
  {
    attributes: {},
    clientRole: false,
    composite: false,
    composites: {
      client: {},
      realm: []
    },
    containerId: '',
    description: '',
    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}}/:realm/users/:id/role-mappings/clients/:client');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client',
  headers: {'content-type': 'application/json'},
  data: [
    {
      attributes: {},
      clientRole: false,
      composite: false,
      composites: {client: {}, realm: []},
      containerId: '',
      description: '',
      id: '',
      name: ''
    }
  ]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '[{"attributes":{},"clientRole":false,"composite":false,"composites":{"client":{},"realm":[]},"containerId":"","description":"","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}}/:realm/users/:id/role-mappings/clients/:client',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  {\n    "attributes": {},\n    "clientRole": false,\n    "composite": false,\n    "composites": {\n      "client": {},\n      "realm": []\n    },\n    "containerId": "",\n    "description": "",\n    "id": "",\n    "name": ""\n  }\n]'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/users/:id/role-mappings/clients/:client',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify([
  {
    attributes: {},
    clientRole: false,
    composite: false,
    composites: {client: {}, realm: []},
    containerId: '',
    description: '',
    id: '',
    name: ''
  }
]));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client',
  headers: {'content-type': 'application/json'},
  body: [
    {
      attributes: {},
      clientRole: false,
      composite: false,
      composites: {client: {}, realm: []},
      containerId: '',
      description: '',
      id: '',
      name: ''
    }
  ],
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send([
  {
    attributes: {},
    clientRole: false,
    composite: false,
    composites: {
      client: {},
      realm: []
    },
    containerId: '',
    description: '',
    id: '',
    name: ''
  }
]);

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client',
  headers: {'content-type': 'application/json'},
  data: [
    {
      attributes: {},
      clientRole: false,
      composite: false,
      composites: {client: {}, realm: []},
      containerId: '',
      description: '',
      id: '',
      name: ''
    }
  ]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '[{"attributes":{},"clientRole":false,"composite":false,"composites":{"client":{},"realm":[]},"containerId":"","description":"","id":"","name":""}]'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @[ @{ @"attributes": @{  }, @"clientRole": @NO, @"composite": @NO, @"composites": @{ @"client": @{  }, @"realm": @[  ] }, @"containerId": @"", @"description": @"", @"id": @"", @"name": @"" } ];

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client"]
                                                       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}}/:realm/users/:id/role-mappings/clients/:client" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    [
        'attributes' => [
                
        ],
        'clientRole' => null,
        'composite' => null,
        'composites' => [
                'client' => [
                                
                ],
                'realm' => [
                                
                ]
        ],
        'containerId' => '',
        'description' => '',
        'id' => '',
        'name' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client', [
  'body' => '[
  {
    "attributes": {},
    "clientRole": false,
    "composite": false,
    "composites": {
      "client": {},
      "realm": []
    },
    "containerId": "",
    "description": "",
    "id": "",
    "name": ""
  }
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    'attributes' => [
        
    ],
    'clientRole' => null,
    'composite' => null,
    'composites' => [
        'client' => [
                
        ],
        'realm' => [
                
        ]
    ],
    'containerId' => '',
    'description' => '',
    'id' => '',
    'name' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  [
    'attributes' => [
        
    ],
    'clientRole' => null,
    'composite' => null,
    'composites' => [
        'client' => [
                
        ],
        'realm' => [
                
        ]
    ],
    'containerId' => '',
    'description' => '',
    'id' => '',
    'name' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  {
    "attributes": {},
    "clientRole": false,
    "composite": false,
    "composites": {
      "client": {},
      "realm": []
    },
    "containerId": "",
    "description": "",
    "id": "",
    "name": ""
  }
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  {
    "attributes": {},
    "clientRole": false,
    "composite": false,
    "composites": {
      "client": {},
      "realm": []
    },
    "containerId": "",
    "description": "",
    "id": "",
    "name": ""
  }
]'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/:realm/users/:id/role-mappings/clients/:client", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client"

payload = [
    {
        "attributes": {},
        "clientRole": False,
        "composite": False,
        "composites": {
            "client": {},
            "realm": []
        },
        "containerId": "",
        "description": "",
        "id": "",
        "name": ""
    }
]
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client"

payload <- "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/:realm/users/:id/role-mappings/clients/:client') do |req|
  req.body = "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client";

    let payload = (
        json!({
            "attributes": json!({}),
            "clientRole": false,
            "composite": false,
            "composites": json!({
                "client": json!({}),
                "realm": ()
            }),
            "containerId": "",
            "description": "",
            "id": "",
            "name": ""
        })
    );

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '[
  {
    "attributes": {},
    "clientRole": false,
    "composite": false,
    "composites": {
      "client": {},
      "realm": []
    },
    "containerId": "",
    "description": "",
    "id": "",
    "name": ""
  }
]' |  \
  http POST {{baseUrl}}/:realm/users/:id/role-mappings/clients/:client \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '[\n  {\n    "attributes": {},\n    "clientRole": false,\n    "composite": false,\n    "composites": {\n      "client": {},\n      "realm": []\n    },\n    "containerId": "",\n    "description": "",\n    "id": "",\n    "name": ""\n  }\n]' \
  --output-document \
  - {{baseUrl}}/:realm/users/:id/role-mappings/clients/:client

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  [
    "attributes": [],
    "clientRole": false,
    "composite": false,
    "composites": [
      "client": [],
      "realm": []
    ],
    "containerId": "",
    "description": "",
    "id": "",
    "name": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client")! 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}}/:realm/groups/:id/role-mappings/clients/:client");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client" {:content-type :json
                                                                                            :form-params [{:attributes {}
                                                                                                           :clientRole false
                                                                                                           :composite false
                                                                                                           :composites {:client {}
                                                                                                                        :realm []}
                                                                                                           :containerId ""
                                                                                                           :description ""
                                                                                                           :id ""
                                                                                                           :name ""}]})

require "http/client"

url = "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client"),
    Content = new StringContent("[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client"

	payload := strings.NewReader("[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/:realm/groups/:id/role-mappings/clients/:client HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 222

[
  {
    "attributes": {},
    "clientRole": false,
    "composite": false,
    "composites": {
      "client": {},
      "realm": []
    },
    "containerId": "",
    "description": "",
    "id": "",
    "name": ""
  }
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client")
  .header("content-type", "application/json")
  .body("[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]")
  .asString();

const data = JSON.stringify([
  {
    attributes: {},
    clientRole: false,
    composite: false,
    composites: {
      client: {},
      realm: []
    },
    containerId: '',
    description: '',
    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}}/:realm/groups/:id/role-mappings/clients/:client');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client',
  headers: {'content-type': 'application/json'},
  data: [
    {
      attributes: {},
      clientRole: false,
      composite: false,
      composites: {client: {}, realm: []},
      containerId: '',
      description: '',
      id: '',
      name: ''
    }
  ]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '[{"attributes":{},"clientRole":false,"composite":false,"composites":{"client":{},"realm":[]},"containerId":"","description":"","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}}/:realm/groups/:id/role-mappings/clients/:client',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  {\n    "attributes": {},\n    "clientRole": false,\n    "composite": false,\n    "composites": {\n      "client": {},\n      "realm": []\n    },\n    "containerId": "",\n    "description": "",\n    "id": "",\n    "name": ""\n  }\n]'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/groups/:id/role-mappings/clients/:client',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify([
  {
    attributes: {},
    clientRole: false,
    composite: false,
    composites: {client: {}, realm: []},
    containerId: '',
    description: '',
    id: '',
    name: ''
  }
]));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client',
  headers: {'content-type': 'application/json'},
  body: [
    {
      attributes: {},
      clientRole: false,
      composite: false,
      composites: {client: {}, realm: []},
      containerId: '',
      description: '',
      id: '',
      name: ''
    }
  ],
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send([
  {
    attributes: {},
    clientRole: false,
    composite: false,
    composites: {
      client: {},
      realm: []
    },
    containerId: '',
    description: '',
    id: '',
    name: ''
  }
]);

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client',
  headers: {'content-type': 'application/json'},
  data: [
    {
      attributes: {},
      clientRole: false,
      composite: false,
      composites: {client: {}, realm: []},
      containerId: '',
      description: '',
      id: '',
      name: ''
    }
  ]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '[{"attributes":{},"clientRole":false,"composite":false,"composites":{"client":{},"realm":[]},"containerId":"","description":"","id":"","name":""}]'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @[ @{ @"attributes": @{  }, @"clientRole": @NO, @"composite": @NO, @"composites": @{ @"client": @{  }, @"realm": @[  ] }, @"containerId": @"", @"description": @"", @"id": @"", @"name": @"" } ];

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client"]
                                                       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}}/:realm/groups/:id/role-mappings/clients/:client" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    [
        'attributes' => [
                
        ],
        'clientRole' => null,
        'composite' => null,
        'composites' => [
                'client' => [
                                
                ],
                'realm' => [
                                
                ]
        ],
        'containerId' => '',
        'description' => '',
        'id' => '',
        'name' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client', [
  'body' => '[
  {
    "attributes": {},
    "clientRole": false,
    "composite": false,
    "composites": {
      "client": {},
      "realm": []
    },
    "containerId": "",
    "description": "",
    "id": "",
    "name": ""
  }
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    'attributes' => [
        
    ],
    'clientRole' => null,
    'composite' => null,
    'composites' => [
        'client' => [
                
        ],
        'realm' => [
                
        ]
    ],
    'containerId' => '',
    'description' => '',
    'id' => '',
    'name' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  [
    'attributes' => [
        
    ],
    'clientRole' => null,
    'composite' => null,
    'composites' => [
        'client' => [
                
        ],
        'realm' => [
                
        ]
    ],
    'containerId' => '',
    'description' => '',
    'id' => '',
    'name' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  {
    "attributes": {},
    "clientRole": false,
    "composite": false,
    "composites": {
      "client": {},
      "realm": []
    },
    "containerId": "",
    "description": "",
    "id": "",
    "name": ""
  }
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  {
    "attributes": {},
    "clientRole": false,
    "composite": false,
    "composites": {
      "client": {},
      "realm": []
    },
    "containerId": "",
    "description": "",
    "id": "",
    "name": ""
  }
]'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/:realm/groups/:id/role-mappings/clients/:client", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client"

payload = [
    {
        "attributes": {},
        "clientRole": False,
        "composite": False,
        "composites": {
            "client": {},
            "realm": []
        },
        "containerId": "",
        "description": "",
        "id": "",
        "name": ""
    }
]
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client"

payload <- "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/:realm/groups/:id/role-mappings/clients/:client') do |req|
  req.body = "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client";

    let payload = (
        json!({
            "attributes": json!({}),
            "clientRole": false,
            "composite": false,
            "composites": json!({
                "client": json!({}),
                "realm": ()
            }),
            "containerId": "",
            "description": "",
            "id": "",
            "name": ""
        })
    );

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '[
  {
    "attributes": {},
    "clientRole": false,
    "composite": false,
    "composites": {
      "client": {},
      "realm": []
    },
    "containerId": "",
    "description": "",
    "id": "",
    "name": ""
  }
]' |  \
  http POST {{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '[\n  {\n    "attributes": {},\n    "clientRole": false,\n    "composite": false,\n    "composites": {\n      "client": {},\n      "realm": []\n    },\n    "containerId": "",\n    "description": "",\n    "id": "",\n    "name": ""\n  }\n]' \
  --output-document \
  - {{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  [
    "attributes": [],
    "clientRole": false,
    "composite": false,
    "composites": [
      "client": [],
      "realm": []
    ],
    "containerId": "",
    "description": "",
    "id": "",
    "name": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client" {:content-type :json
                                                                                             :form-params [{:attributes {}
                                                                                                            :clientRole false
                                                                                                            :composite false
                                                                                                            :composites {:client {}
                                                                                                                         :realm []}
                                                                                                            :containerId ""
                                                                                                            :description ""
                                                                                                            :id ""
                                                                                                            :name ""}]})

require "http/client"

url = "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]"

response = HTTP::Client.delete url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client"),
    Content = new StringContent("[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client");
var request = new RestRequest("", Method.Delete);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client"

	payload := strings.NewReader("[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]")

	req, _ := http.NewRequest("DELETE", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/:realm/users/:id/role-mappings/clients/:client HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 222

[
  {
    "attributes": {},
    "clientRole": false,
    "composite": false,
    "composites": {
      "client": {},
      "realm": []
    },
    "containerId": "",
    "description": "",
    "id": "",
    "name": ""
  }
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client"))
    .header("content-type", "application/json")
    .method("DELETE", HttpRequest.BodyPublishers.ofString("[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client")
  .delete(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client")
  .header("content-type", "application/json")
  .body("[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]")
  .asString();

const data = JSON.stringify([
  {
    attributes: {},
    clientRole: false,
    composite: false,
    composites: {
      client: {},
      realm: []
    },
    containerId: '',
    description: '',
    id: '',
    name: ''
  }
]);

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client',
  headers: {'content-type': 'application/json'},
  data: [
    {
      attributes: {},
      clientRole: false,
      composite: false,
      composites: {client: {}, realm: []},
      containerId: '',
      description: '',
      id: '',
      name: ''
    }
  ]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client';
const options = {
  method: 'DELETE',
  headers: {'content-type': 'application/json'},
  body: '[{"attributes":{},"clientRole":false,"composite":false,"composites":{"client":{},"realm":[]},"containerId":"","description":"","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}}/:realm/users/:id/role-mappings/clients/:client',
  method: 'DELETE',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  {\n    "attributes": {},\n    "clientRole": false,\n    "composite": false,\n    "composites": {\n      "client": {},\n      "realm": []\n    },\n    "containerId": "",\n    "description": "",\n    "id": "",\n    "name": ""\n  }\n]'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client")
  .delete(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/users/:id/role-mappings/clients/:client',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify([
  {
    attributes: {},
    clientRole: false,
    composite: false,
    composites: {client: {}, realm: []},
    containerId: '',
    description: '',
    id: '',
    name: ''
  }
]));
req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client',
  headers: {'content-type': 'application/json'},
  body: [
    {
      attributes: {},
      clientRole: false,
      composite: false,
      composites: {client: {}, realm: []},
      containerId: '',
      description: '',
      id: '',
      name: ''
    }
  ],
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send([
  {
    attributes: {},
    clientRole: false,
    composite: false,
    composites: {
      client: {},
      realm: []
    },
    containerId: '',
    description: '',
    id: '',
    name: ''
  }
]);

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client',
  headers: {'content-type': 'application/json'},
  data: [
    {
      attributes: {},
      clientRole: false,
      composite: false,
      composites: {client: {}, realm: []},
      containerId: '',
      description: '',
      id: '',
      name: ''
    }
  ]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client';
const options = {
  method: 'DELETE',
  headers: {'content-type': 'application/json'},
  body: '[{"attributes":{},"clientRole":false,"composite":false,"composites":{"client":{},"realm":[]},"containerId":"","description":"","id":"","name":""}]'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @[ @{ @"attributes": @{  }, @"clientRole": @NO, @"composite": @NO, @"composites": @{ @"client": @{  }, @"realm": @[  ] }, @"containerId": @"", @"description": @"", @"id": @"", @"name": @"" } ];

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[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}}/:realm/users/:id/role-mappings/clients/:client" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]" in

Client.call ~headers ~body `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_POSTFIELDS => json_encode([
    [
        'attributes' => [
                
        ],
        'clientRole' => null,
        'composite' => null,
        'composites' => [
                'client' => [
                                
                ],
                'realm' => [
                                
                ]
        ],
        'containerId' => '',
        'description' => '',
        'id' => '',
        'name' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client', [
  'body' => '[
  {
    "attributes": {},
    "clientRole": false,
    "composite": false,
    "composites": {
      "client": {},
      "realm": []
    },
    "containerId": "",
    "description": "",
    "id": "",
    "name": ""
  }
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    'attributes' => [
        
    ],
    'clientRole' => null,
    'composite' => null,
    'composites' => [
        'client' => [
                
        ],
        'realm' => [
                
        ]
    ],
    'containerId' => '',
    'description' => '',
    'id' => '',
    'name' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  [
    'attributes' => [
        
    ],
    'clientRole' => null,
    'composite' => null,
    'composites' => [
        'client' => [
                
        ],
        'realm' => [
                
        ]
    ],
    'containerId' => '',
    'description' => '',
    'id' => '',
    'name' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client');
$request->setRequestMethod('DELETE');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client' -Method DELETE -Headers $headers -ContentType 'application/json' -Body '[
  {
    "attributes": {},
    "clientRole": false,
    "composite": false,
    "composites": {
      "client": {},
      "realm": []
    },
    "containerId": "",
    "description": "",
    "id": "",
    "name": ""
  }
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client' -Method DELETE -Headers $headers -ContentType 'application/json' -Body '[
  {
    "attributes": {},
    "clientRole": false,
    "composite": false,
    "composites": {
      "client": {},
      "realm": []
    },
    "containerId": "",
    "description": "",
    "id": "",
    "name": ""
  }
]'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]"

headers = { 'content-type': "application/json" }

conn.request("DELETE", "/baseUrl/:realm/users/:id/role-mappings/clients/:client", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client"

payload = [
    {
        "attributes": {},
        "clientRole": False,
        "composite": False,
        "composites": {
            "client": {},
            "realm": []
        },
        "containerId": "",
        "description": "",
        "id": "",
        "name": ""
    }
]
headers = {"content-type": "application/json"}

response = requests.delete(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client"

payload <- "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]"

encode <- "json"

response <- VERB("DELETE", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["content-type"] = 'application/json'
request.body = "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.delete('/baseUrl/:realm/users/:id/role-mappings/clients/:client') do |req|
  req.body = "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client";

    let payload = (
        json!({
            "attributes": json!({}),
            "clientRole": false,
            "composite": false,
            "composites": json!({
                "client": json!({}),
                "realm": ()
            }),
            "containerId": "",
            "description": "",
            "id": "",
            "name": ""
        })
    );

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '[
  {
    "attributes": {},
    "clientRole": false,
    "composite": false,
    "composites": {
      "client": {},
      "realm": []
    },
    "containerId": "",
    "description": "",
    "id": "",
    "name": ""
  }
]' |  \
  http DELETE {{baseUrl}}/:realm/users/:id/role-mappings/clients/:client \
  content-type:application/json

wget --quiet \
  --method DELETE \
  --header 'content-type: application/json' \
  --body-data '[\n  {\n    "attributes": {},\n    "clientRole": false,\n    "composite": false,\n    "composites": {\n      "client": {},\n      "realm": []\n    },\n    "containerId": "",\n    "description": "",\n    "id": "",\n    "name": ""\n  }\n]' \
  --output-document \
  - {{baseUrl}}/:realm/users/:id/role-mappings/clients/:client

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  [
    "attributes": [],
    "clientRole": false,
    "composite": false,
    "composites": [
      "client": [],
      "realm": []
    ],
    "containerId": "",
    "description": "",
    "id": "",
    "name": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client" {:content-type :json
                                                                                              :form-params [{:attributes {}
                                                                                                             :clientRole false
                                                                                                             :composite false
                                                                                                             :composites {:client {}
                                                                                                                          :realm []}
                                                                                                             :containerId ""
                                                                                                             :description ""
                                                                                                             :id ""
                                                                                                             :name ""}]})

require "http/client"

url = "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]"

response = HTTP::Client.delete url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client"),
    Content = new StringContent("[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client");
var request = new RestRequest("", Method.Delete);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client"

	payload := strings.NewReader("[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]")

	req, _ := http.NewRequest("DELETE", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/:realm/groups/:id/role-mappings/clients/:client HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 222

[
  {
    "attributes": {},
    "clientRole": false,
    "composite": false,
    "composites": {
      "client": {},
      "realm": []
    },
    "containerId": "",
    "description": "",
    "id": "",
    "name": ""
  }
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client"))
    .header("content-type", "application/json")
    .method("DELETE", HttpRequest.BodyPublishers.ofString("[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client")
  .delete(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client")
  .header("content-type", "application/json")
  .body("[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]")
  .asString();

const data = JSON.stringify([
  {
    attributes: {},
    clientRole: false,
    composite: false,
    composites: {
      client: {},
      realm: []
    },
    containerId: '',
    description: '',
    id: '',
    name: ''
  }
]);

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client',
  headers: {'content-type': 'application/json'},
  data: [
    {
      attributes: {},
      clientRole: false,
      composite: false,
      composites: {client: {}, realm: []},
      containerId: '',
      description: '',
      id: '',
      name: ''
    }
  ]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client';
const options = {
  method: 'DELETE',
  headers: {'content-type': 'application/json'},
  body: '[{"attributes":{},"clientRole":false,"composite":false,"composites":{"client":{},"realm":[]},"containerId":"","description":"","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}}/:realm/groups/:id/role-mappings/clients/:client',
  method: 'DELETE',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  {\n    "attributes": {},\n    "clientRole": false,\n    "composite": false,\n    "composites": {\n      "client": {},\n      "realm": []\n    },\n    "containerId": "",\n    "description": "",\n    "id": "",\n    "name": ""\n  }\n]'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client")
  .delete(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/groups/:id/role-mappings/clients/:client',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify([
  {
    attributes: {},
    clientRole: false,
    composite: false,
    composites: {client: {}, realm: []},
    containerId: '',
    description: '',
    id: '',
    name: ''
  }
]));
req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client',
  headers: {'content-type': 'application/json'},
  body: [
    {
      attributes: {},
      clientRole: false,
      composite: false,
      composites: {client: {}, realm: []},
      containerId: '',
      description: '',
      id: '',
      name: ''
    }
  ],
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send([
  {
    attributes: {},
    clientRole: false,
    composite: false,
    composites: {
      client: {},
      realm: []
    },
    containerId: '',
    description: '',
    id: '',
    name: ''
  }
]);

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client',
  headers: {'content-type': 'application/json'},
  data: [
    {
      attributes: {},
      clientRole: false,
      composite: false,
      composites: {client: {}, realm: []},
      containerId: '',
      description: '',
      id: '',
      name: ''
    }
  ]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client';
const options = {
  method: 'DELETE',
  headers: {'content-type': 'application/json'},
  body: '[{"attributes":{},"clientRole":false,"composite":false,"composites":{"client":{},"realm":[]},"containerId":"","description":"","id":"","name":""}]'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @[ @{ @"attributes": @{  }, @"clientRole": @NO, @"composite": @NO, @"composites": @{ @"client": @{  }, @"realm": @[  ] }, @"containerId": @"", @"description": @"", @"id": @"", @"name": @"" } ];

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[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}}/:realm/groups/:id/role-mappings/clients/:client" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]" in

Client.call ~headers ~body `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_POSTFIELDS => json_encode([
    [
        'attributes' => [
                
        ],
        'clientRole' => null,
        'composite' => null,
        'composites' => [
                'client' => [
                                
                ],
                'realm' => [
                                
                ]
        ],
        'containerId' => '',
        'description' => '',
        'id' => '',
        'name' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client', [
  'body' => '[
  {
    "attributes": {},
    "clientRole": false,
    "composite": false,
    "composites": {
      "client": {},
      "realm": []
    },
    "containerId": "",
    "description": "",
    "id": "",
    "name": ""
  }
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    'attributes' => [
        
    ],
    'clientRole' => null,
    'composite' => null,
    'composites' => [
        'client' => [
                
        ],
        'realm' => [
                
        ]
    ],
    'containerId' => '',
    'description' => '',
    'id' => '',
    'name' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  [
    'attributes' => [
        
    ],
    'clientRole' => null,
    'composite' => null,
    'composites' => [
        'client' => [
                
        ],
        'realm' => [
                
        ]
    ],
    'containerId' => '',
    'description' => '',
    'id' => '',
    'name' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client');
$request->setRequestMethod('DELETE');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client' -Method DELETE -Headers $headers -ContentType 'application/json' -Body '[
  {
    "attributes": {},
    "clientRole": false,
    "composite": false,
    "composites": {
      "client": {},
      "realm": []
    },
    "containerId": "",
    "description": "",
    "id": "",
    "name": ""
  }
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client' -Method DELETE -Headers $headers -ContentType 'application/json' -Body '[
  {
    "attributes": {},
    "clientRole": false,
    "composite": false,
    "composites": {
      "client": {},
      "realm": []
    },
    "containerId": "",
    "description": "",
    "id": "",
    "name": ""
  }
]'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]"

headers = { 'content-type': "application/json" }

conn.request("DELETE", "/baseUrl/:realm/groups/:id/role-mappings/clients/:client", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client"

payload = [
    {
        "attributes": {},
        "clientRole": False,
        "composite": False,
        "composites": {
            "client": {},
            "realm": []
        },
        "containerId": "",
        "description": "",
        "id": "",
        "name": ""
    }
]
headers = {"content-type": "application/json"}

response = requests.delete(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client"

payload <- "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]"

encode <- "json"

response <- VERB("DELETE", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["content-type"] = 'application/json'
request.body = "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.delete('/baseUrl/:realm/groups/:id/role-mappings/clients/:client') do |req|
  req.body = "[\n  {\n    \"attributes\": {},\n    \"clientRole\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"client\": {},\n      \"realm\": []\n    },\n    \"containerId\": \"\",\n    \"description\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  }\n]"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client";

    let payload = (
        json!({
            "attributes": json!({}),
            "clientRole": false,
            "composite": false,
            "composites": json!({
                "client": json!({}),
                "realm": ()
            }),
            "containerId": "",
            "description": "",
            "id": "",
            "name": ""
        })
    );

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '[
  {
    "attributes": {},
    "clientRole": false,
    "composite": false,
    "composites": {
      "client": {},
      "realm": []
    },
    "containerId": "",
    "description": "",
    "id": "",
    "name": ""
  }
]' |  \
  http DELETE {{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client \
  content-type:application/json

wget --quiet \
  --method DELETE \
  --header 'content-type: application/json' \
  --body-data '[\n  {\n    "attributes": {},\n    "clientRole": false,\n    "composite": false,\n    "composites": {\n      "client": {},\n      "realm": []\n    },\n    "containerId": "",\n    "description": "",\n    "id": "",\n    "name": ""\n  }\n]' \
  --output-document \
  - {{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  [
    "attributes": [],
    "clientRole": false,
    "composite": false,
    "composites": [
      "client": [],
      "realm": []
    ],
    "containerId": "",
    "description": "",
    "id": "",
    "name": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
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}}/:realm/users/:id/role-mappings/clients/:client/available");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/available")

require "http/client"

url = "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/available"

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}}/:realm/users/:id/role-mappings/clients/:client/available"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/available");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/available"

	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/:realm/users/:id/role-mappings/clients/:client/available HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/available")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/available"))
    .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}}/:realm/users/:id/role-mappings/clients/:client/available")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/available")
  .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}}/:realm/users/:id/role-mappings/clients/:client/available');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/available'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/available';
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}}/:realm/users/:id/role-mappings/clients/:client/available',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/available")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/users/:id/role-mappings/clients/:client/available',
  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}}/:realm/users/:id/role-mappings/clients/:client/available'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/available');

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}}/:realm/users/:id/role-mappings/clients/:client/available'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/available';
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}}/:realm/users/:id/role-mappings/clients/:client/available"]
                                                       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}}/:realm/users/:id/role-mappings/clients/:client/available" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/available",
  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}}/:realm/users/:id/role-mappings/clients/:client/available');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/available');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/available');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/available' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/available' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/:realm/users/:id/role-mappings/clients/:client/available")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/available"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/available"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/available")

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/:realm/users/:id/role-mappings/clients/:client/available') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/available";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/available

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/available

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/available")! 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}}/:realm/groups/:id/role-mappings/clients/:client/available");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/available")

require "http/client"

url = "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/available"

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}}/:realm/groups/:id/role-mappings/clients/:client/available"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/available");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/available"

	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/:realm/groups/:id/role-mappings/clients/:client/available HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/available")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/available"))
    .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}}/:realm/groups/:id/role-mappings/clients/:client/available")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/available")
  .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}}/:realm/groups/:id/role-mappings/clients/:client/available');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/available'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/available';
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}}/:realm/groups/:id/role-mappings/clients/:client/available',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/available")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/groups/:id/role-mappings/clients/:client/available',
  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}}/:realm/groups/:id/role-mappings/clients/:client/available'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/available');

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}}/:realm/groups/:id/role-mappings/clients/:client/available'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/available';
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}}/:realm/groups/:id/role-mappings/clients/:client/available"]
                                                       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}}/:realm/groups/:id/role-mappings/clients/:client/available" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/available",
  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}}/:realm/groups/:id/role-mappings/clients/:client/available');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/available');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/available');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/available' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/available' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/:realm/groups/:id/role-mappings/clients/:client/available")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/available"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/available"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/available")

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/:realm/groups/:id/role-mappings/clients/:client/available') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/available";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/available

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/available

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/available")! 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}}/:realm/users/:id/role-mappings/clients/:client");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client")

require "http/client"

url = "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client"

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}}/:realm/users/:id/role-mappings/clients/:client"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client"

	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/:realm/users/:id/role-mappings/clients/:client HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client"))
    .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}}/:realm/users/:id/role-mappings/clients/:client")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client")
  .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}}/:realm/users/:id/role-mappings/clients/:client');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client';
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}}/:realm/users/:id/role-mappings/clients/:client',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/users/:id/role-mappings/clients/:client',
  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}}/:realm/users/:id/role-mappings/clients/:client'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client');

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}}/:realm/users/:id/role-mappings/clients/:client'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client';
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}}/:realm/users/:id/role-mappings/clients/:client"]
                                                       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}}/:realm/users/:id/role-mappings/clients/:client" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client",
  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}}/:realm/users/:id/role-mappings/clients/:client');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/:realm/users/:id/role-mappings/clients/:client")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client")

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/:realm/users/:id/role-mappings/clients/:client') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/:realm/users/:id/role-mappings/clients/:client

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/:realm/users/:id/role-mappings/clients/:client

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client")! 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}}/:realm/groups/:id/role-mappings/clients/:client");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client")

require "http/client"

url = "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client"

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}}/:realm/groups/:id/role-mappings/clients/:client"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client"

	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/:realm/groups/:id/role-mappings/clients/:client HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client"))
    .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}}/:realm/groups/:id/role-mappings/clients/:client")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client")
  .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}}/:realm/groups/:id/role-mappings/clients/:client');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client';
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}}/:realm/groups/:id/role-mappings/clients/:client',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/groups/:id/role-mappings/clients/:client',
  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}}/:realm/groups/:id/role-mappings/clients/:client'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client');

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}}/:realm/groups/:id/role-mappings/clients/:client'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client';
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}}/:realm/groups/:id/role-mappings/clients/:client"]
                                                       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}}/:realm/groups/:id/role-mappings/clients/:client" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client",
  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}}/:realm/groups/:id/role-mappings/clients/:client');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/:realm/groups/:id/role-mappings/clients/:client")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client")

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/:realm/groups/:id/role-mappings/clients/:client') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client")! 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}}/:realm/users/:id/role-mappings/clients/:client/composite");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/composite")

require "http/client"

url = "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/composite"

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}}/:realm/users/:id/role-mappings/clients/:client/composite"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/composite");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/composite"

	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/:realm/users/:id/role-mappings/clients/:client/composite HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/composite")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/composite"))
    .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}}/:realm/users/:id/role-mappings/clients/:client/composite")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/composite")
  .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}}/:realm/users/:id/role-mappings/clients/:client/composite');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/composite'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/composite';
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}}/:realm/users/:id/role-mappings/clients/:client/composite',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/composite")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/users/:id/role-mappings/clients/:client/composite',
  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}}/:realm/users/:id/role-mappings/clients/:client/composite'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/composite');

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}}/:realm/users/:id/role-mappings/clients/:client/composite'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/composite';
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}}/:realm/users/:id/role-mappings/clients/:client/composite"]
                                                       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}}/:realm/users/:id/role-mappings/clients/:client/composite" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/composite",
  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}}/:realm/users/:id/role-mappings/clients/:client/composite');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/composite');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/composite');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/composite' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/composite' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/:realm/users/:id/role-mappings/clients/:client/composite")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/composite"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/composite"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/composite")

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/:realm/users/:id/role-mappings/clients/:client/composite') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/composite";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/composite

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/composite

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/users/:id/role-mappings/clients/:client/composite")! 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}}/:realm/groups/:id/role-mappings/clients/:client/composite");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/composite")

require "http/client"

url = "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/composite"

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}}/:realm/groups/:id/role-mappings/clients/:client/composite"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/composite");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/composite"

	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/:realm/groups/:id/role-mappings/clients/:client/composite HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/composite")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/composite"))
    .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}}/:realm/groups/:id/role-mappings/clients/:client/composite")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/composite")
  .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}}/:realm/groups/:id/role-mappings/clients/:client/composite');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/composite'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/composite';
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}}/:realm/groups/:id/role-mappings/clients/:client/composite',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/composite")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/groups/:id/role-mappings/clients/:client/composite',
  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}}/:realm/groups/:id/role-mappings/clients/:client/composite'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/composite');

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}}/:realm/groups/:id/role-mappings/clients/:client/composite'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/composite';
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}}/:realm/groups/:id/role-mappings/clients/:client/composite"]
                                                       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}}/:realm/groups/:id/role-mappings/clients/:client/composite" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/composite",
  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}}/:realm/groups/:id/role-mappings/clients/:client/composite');

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/composite');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/composite');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/composite' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/composite' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/:realm/groups/:id/role-mappings/clients/:client/composite")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/composite"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/composite"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/composite")

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/:realm/groups/:id/role-mappings/clients/:client/composite') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/composite";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/composite

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/composite

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/:realm/groups/:id/role-mappings/clients/:client/composite")! 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}}/:realm/client-scopes");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\",\n  \"protocol\": \"\",\n  \"protocolMappers\": [\n    {\n      \"config\": {},\n      \"id\": \"\",\n      \"name\": \"\",\n      \"protocol\": \"\",\n      \"protocolMapper\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/:realm/client-scopes" {:content-type :json
                                                                 :form-params {:attributes {}
                                                                               :description ""
                                                                               :id ""
                                                                               :name ""
                                                                               :protocol ""
                                                                               :protocolMappers [{:config {}
                                                                                                  :id ""
                                                                                                  :name ""
                                                                                                  :protocol ""
                                                                                                  :protocolMapper ""}]}})

require "http/client"

url = "{{baseUrl}}/:realm/client-scopes"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\",\n  \"protocol\": \"\",\n  \"protocolMappers\": [\n    {\n      \"config\": {},\n      \"id\": \"\",\n      \"name\": \"\",\n      \"protocol\": \"\",\n      \"protocolMapper\": \"\"\n    }\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/:realm/client-scopes"),
    Content = new StringContent("{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\",\n  \"protocol\": \"\",\n  \"protocolMappers\": [\n    {\n      \"config\": {},\n      \"id\": \"\",\n      \"name\": \"\",\n      \"protocol\": \"\",\n      \"protocolMapper\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/:realm/client-scopes");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\",\n  \"protocol\": \"\",\n  \"protocolMappers\": [\n    {\n      \"config\": {},\n      \"id\": \"\",\n      \"name\": \"\",\n      \"protocol\": \"\",\n      \"protocolMapper\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/:realm/client-scopes"

	payload := strings.NewReader("{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\",\n  \"protocol\": \"\",\n  \"protocolMappers\": [\n    {\n      \"config\": {},\n      \"id\": \"\",\n      \"name\": \"\",\n      \"protocol\": \"\",\n      \"protocolMapper\": \"\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/:realm/client-scopes HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 230

{
  "attributes": {},
  "description": "",
  "id": "",
  "name": "",
  "protocol": "",
  "protocolMappers": [
    {
      "config": {},
      "id": "",
      "name": "",
      "protocol": "",
      "protocolMapper": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/:realm/client-scopes")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\",\n  \"protocol\": \"\",\n  \"protocolMappers\": [\n    {\n      \"config\": {},\n      \"id\": \"\",\n      \"name\": \"\",\n      \"protocol\": \"\",\n      \"protocolMapper\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/:realm/client-scopes"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\",\n  \"protocol\": \"\",\n  \"protocolMappers\": [\n    {\n      \"config\": {},\n      \"id\": \"\",\n      \"name\": \"\",\n      \"protocol\": \"\",\n      \"protocolMapper\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\",\n  \"protocol\": \"\",\n  \"protocolMappers\": [\n    {\n      \"config\": {},\n      \"id\": \"\",\n      \"name\": \"\",\n      \"protocol\": \"\",\n      \"protocolMapper\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/:realm/client-scopes")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/:realm/client-scopes")
  .header("content-type", "application/json")
  .body("{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\",\n  \"protocol\": \"\",\n  \"protocolMappers\": [\n    {\n      \"config\": {},\n      \"id\": \"\",\n      \"name\": \"\",\n      \"protocol\": \"\",\n      \"protocolMapper\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  attributes: {},
  description: '',
  id: '',
  name: '',
  protocol: '',
  protocolMappers: [
    {
      config: {},
      id: '',
      name: '',
      protocol: '',
      protocolMapper: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/:realm/client-scopes');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/client-scopes',
  headers: {'content-type': 'application/json'},
  data: {
    attributes: {},
    description: '',
    id: '',
    name: '',
    protocol: '',
    protocolMappers: [{config: {}, id: '', name: '', protocol: '', protocolMapper: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/:realm/client-scopes';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"attributes":{},"description":"","id":"","name":"","protocol":"","protocolMappers":[{"config":{},"id":"","name":"","protocol":"","protocolMapper":""}]}'
};

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}}/:realm/client-scopes',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "attributes": {},\n  "description": "",\n  "id": "",\n  "name": "",\n  "protocol": "",\n  "protocolMappers": [\n    {\n      "config": {},\n      "id": "",\n      "name": "",\n      "protocol": "",\n      "protocolMapper": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\",\n  \"protocol\": \"\",\n  \"protocolMappers\": [\n    {\n      \"config\": {},\n      \"id\": \"\",\n      \"name\": \"\",\n      \"protocol\": \"\",\n      \"protocolMapper\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/:realm/client-scopes")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/:realm/client-scopes',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  attributes: {},
  description: '',
  id: '',
  name: '',
  protocol: '',
  protocolMappers: [{config: {}, id: '', name: '', protocol: '', protocolMapper: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/client-scopes',
  headers: {'content-type': 'application/json'},
  body: {
    attributes: {},
    description: '',
    id: '',
    name: '',
    protocol: '',
    protocolMappers: [{config: {}, id: '', name: '', protocol: '', protocolMapper: ''}]
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/:realm/client-scopes');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  attributes: {},
  description: '',
  id: '',
  name: '',
  protocol: '',
  protocolMappers: [
    {
      config: {},
      id: '',
      name: '',
      protocol: '',
      protocolMapper: ''
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/:realm/client-scopes',
  headers: {'content-type': 'application/json'},
  data: {
    attributes: {},
    description: '',
    id: '',
    name: '',
    protocol: '',
    protocolMappers: [{config: {}, id: '', name: '', protocol: '', protocolMapper: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/:realm/client-scopes';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"attributes":{},"description":"","id":"","name":"","protocol":"","protocolMappers":[{"config":{},"id":"","name":"","protocol":"","protocolMapper":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"attributes": @{  },
                              @"description": @"",
                              @"id": @"",
                              @"name": @"",
                              @"protocol": @"",
                              @"protocolMappers": @[ @{ @"config": @{  }, @"id": @"", @"name": @"", @"protocol": @"", @"protocolMapper": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/:realm/client-scopes"]
                                                       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}}/:realm/client-scopes" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\",\n  \"protocol\": \"\",\n  \"protocolMappers\": [\n    {\n      \"config\": {},\n      \"id\": \"\",\n      \"name\": \"\",\n      \"protocol\": \"\",\n      \"protocolMapper\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/:realm/client-scopes",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'attributes' => [
        
    ],
    'description' => '',
    'id' => '',
    'name' => '',
    'protocol' => '',
    'protocolMappers' => [
        [
                'config' => [
                                
                ],
                'id' => '',
                'name' => '',
                'protocol' => '',
                'protocolMapper' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/:realm/client-scopes', [
  'body' => '{
  "attributes": {},
  "description": "",
  "id": "",
  "name": "",
  "protocol": "",
  "protocolMappers": [
    {
      "config": {},
      "id": "",
      "name": "",
      "protocol": "",
      "protocolMapper": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/:realm/client-scopes');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'attributes' => [
    
  ],
  'description' => '',
  'id' => '',
  'name' => '',
  'protocol' => '',
  'protocolMappers' => [
    [
        'config' => [
                
        ],
        'id' => '',
        'name' => '',
        'protocol' => '',
        'protocolMapper' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'attributes' => [
    
  ],
  'description' => '',
  'id' => '',
  'name' => '',
  'protocol' => '',
  'protocolMappers' => [
    [
        'config' => [
                
        ],
        'id' => '',
        'name' => '',
        'protocol' => '',
        'protocolMapper' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/:realm/client-scopes');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/:realm/client-scopes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "attributes": {},
  "description": "",
  "id": "",
  "name": "",
  "protocol": "",
  "protocolMappers": [
    {
      "config": {},
      "id": "",
      "name": "",
      "protocol": "",
      "protocolMapper": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/:realm/client-scopes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "attributes": {},
  "description": "",
  "id": "",
  "name": "",
  "protocol": "",
  "protocolMappers": [
    {
      "config": {},
      "id": "",
      "name": "",
      "protocol": "",
      "protocolMapper": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\",\n  \"protocol\": \"\",\n  \"protocolMappers\": [\n    {\n      \"config\": {},\n      \"id\": \"\",\n      \"name\": \"\",\n      \"protocol\": \"\",\n      \"protocolMapper\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/:realm/client-scopes", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/:realm/client-scopes"

payload = {
    "attributes": {},
    "description": "",
    "id": "",
    "name": "",
    "protocol": "",
    "protocolMappers": [
        {
            "config": {},
            "id": "",
            "name": "",
            "protocol": "",
            "protocolMapper": ""
        }
    ]
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/:realm/client-scopes"

payload <- "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\",\n  \"protocol\": \"\",\n  \"protocolMappers\": [\n    {\n      \"config\": {},\n      \"id\": \"\",\n      \"name\": \"\",\n      \"protocol\": \"\",\n      \"protocolMapper\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/:realm/client-scopes")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\",\n  \"protocol\": \"\",\n  \"protocolMappers\": [\n    {\n      \"config\": {},\n      \"id\": \"\",\n      \"name\": \"\",\n      \"protocol\": \"\",\n      \"protocolMapper\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body