CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/:realm/attack-detection/brute-force/users HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

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

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/attack-detection/brute-force/users');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

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

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/attack-detection/brute-force/users

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

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/attack-detection/brute-force/users/:userId");

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/:realm/attack-detection/brute-force/users/:userId HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/attack-detection/brute-force/users/:userId" in

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

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

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/attack-detection/brute-force/users/:userId' -Method DELETE 

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

import http.client

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

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

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

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

import requests

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

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/attack-detection/brute-force/users/:userId

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

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/attack-detection/brute-force/users/:userId");

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/:realm/attack-detection/brute-force/users/:userId HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/attack-detection/brute-force/users/:userId" in

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

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

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/attack-detection/brute-force/users/:userId' -Method GET 

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

import http.client

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

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

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

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

import requests

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

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/attack-detection/brute-force/users/:userId

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

import Foundation

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

require "http/client"

url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/flows/:flowAlias/executions/execution', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/:realm/authentication/flows/:flowAlias/executions/execution", payload, headers)

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

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

import requests

url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/flows/:flowAlias/executions/execution \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - {{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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  \"authenticatorConfig\": \"\",\n  \"authenticator\": \"\",\n  \"authenticatorFlow\": false,\n  \"requirement\": \"\",\n  \"priority\": 0,\n  \"autheticatorFlow\": false,\n  \"id\": \"\",\n  \"flowId\": \"\",\n  \"parentFlow\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/admin/realms/:realm/authentication/executions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"authenticatorConfig\": \"\",\n  \"authenticator\": \"\",\n  \"authenticatorFlow\": false,\n  \"requirement\": \"\",\n  \"priority\": 0,\n  \"autheticatorFlow\": false,\n  \"id\": \"\",\n  \"flowId\": \"\",\n  \"parentFlow\": \"\"\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}}/admin/realms/:realm/authentication/executions"),
    Content = new StringContent("{\n  \"authenticatorConfig\": \"\",\n  \"authenticator\": \"\",\n  \"authenticatorFlow\": false,\n  \"requirement\": \"\",\n  \"priority\": 0,\n  \"autheticatorFlow\": false,\n  \"id\": \"\",\n  \"flowId\": \"\",\n  \"parentFlow\": \"\"\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}}/admin/realms/:realm/authentication/executions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"authenticatorConfig\": \"\",\n  \"authenticator\": \"\",\n  \"authenticatorFlow\": false,\n  \"requirement\": \"\",\n  \"priority\": 0,\n  \"autheticatorFlow\": false,\n  \"id\": \"\",\n  \"flowId\": \"\",\n  \"parentFlow\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"authenticatorConfig\": \"\",\n  \"authenticator\": \"\",\n  \"authenticatorFlow\": false,\n  \"requirement\": \"\",\n  \"priority\": 0,\n  \"autheticatorFlow\": false,\n  \"id\": \"\",\n  \"flowId\": \"\",\n  \"parentFlow\": \"\"\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/admin/realms/:realm/authentication/executions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 199

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

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/:realm/authentication/executions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"authenticatorConfig\": \"\",\n  \"authenticator\": \"\",\n  \"authenticatorFlow\": false,\n  \"requirement\": \"\",\n  \"priority\": 0,\n  \"autheticatorFlow\": false,\n  \"id\": \"\",\n  \"flowId\": \"\",\n  \"parentFlow\": \"\"\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  \"authenticatorConfig\": \"\",\n  \"authenticator\": \"\",\n  \"authenticatorFlow\": false,\n  \"requirement\": \"\",\n  \"priority\": 0,\n  \"autheticatorFlow\": false,\n  \"id\": \"\",\n  \"flowId\": \"\",\n  \"parentFlow\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin/realms/:realm/authentication/executions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

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

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

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/realms/:realm/authentication/executions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "authenticatorConfig": "",\n  "authenticator": "",\n  "authenticatorFlow": false,\n  "requirement": "",\n  "priority": 0,\n  "autheticatorFlow": false,\n  "id": "",\n  "flowId": "",\n  "parentFlow": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"authenticatorConfig\": \"\",\n  \"authenticator\": \"\",\n  \"authenticatorFlow\": false,\n  \"requirement\": \"\",\n  \"priority\": 0,\n  \"autheticatorFlow\": false,\n  \"id\": \"\",\n  \"flowId\": \"\",\n  \"parentFlow\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/admin/realms/: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/admin/realms/: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({
  authenticatorConfig: '',
  authenticator: '',
  authenticatorFlow: false,
  requirement: '',
  priority: 0,
  autheticatorFlow: false,
  id: '',
  flowId: '',
  parentFlow: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/executions',
  headers: {'content-type': 'application/json'},
  body: {
    authenticatorConfig: '',
    authenticator: '',
    authenticatorFlow: false,
    requirement: '',
    priority: 0,
    autheticatorFlow: false,
    id: '',
    flowId: '',
    parentFlow: ''
  },
  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}}/admin/realms/:realm/authentication/executions');

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

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

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

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

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

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

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 = @{ @"authenticatorConfig": @"",
                              @"authenticator": @"",
                              @"authenticatorFlow": @NO,
                              @"requirement": @"",
                              @"priority": @0,
                              @"autheticatorFlow": @NO,
                              @"id": @"",
                              @"flowId": @"",
                              @"parentFlow": @"" };

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

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

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

 "{{baseUrl}}/admin/realms/: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([
    'authenticatorConfig' => '',
    'authenticator' => '',
    'authenticatorFlow' => null,
    'requirement' => '',
    'priority' => 0,
    'autheticatorFlow' => null,
    'id' => '',
    'flowId' => '',
    'parentFlow' => ''
  ]),
  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}}/admin/realms/:realm/authentication/executions', [
  'body' => '{
  "authenticatorConfig": "",
  "authenticator": "",
  "authenticatorFlow": false,
  "requirement": "",
  "priority": 0,
  "autheticatorFlow": false,
  "id": "",
  "flowId": "",
  "parentFlow": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'authenticatorConfig' => '',
  'authenticator' => '',
  'authenticatorFlow' => null,
  'requirement' => '',
  'priority' => 0,
  'autheticatorFlow' => null,
  'id' => '',
  'flowId' => '',
  'parentFlow' => ''
]));
$request->setRequestUrl('{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/executions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "authenticatorConfig": "",
  "authenticator": "",
  "authenticatorFlow": false,
  "requirement": "",
  "priority": 0,
  "autheticatorFlow": false,
  "id": "",
  "flowId": "",
  "parentFlow": ""
}'

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

import http.client

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

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

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

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

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

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

import requests

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

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

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

print(response.json())

library(httr)

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

payload <- "{\n  \"authenticatorConfig\": \"\",\n  \"authenticator\": \"\",\n  \"authenticatorFlow\": false,\n  \"requirement\": \"\",\n  \"priority\": 0,\n  \"autheticatorFlow\": false,\n  \"id\": \"\",\n  \"flowId\": \"\",\n  \"parentFlow\": \"\"\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}}/admin/realms/: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  \"authenticatorConfig\": \"\",\n  \"authenticator\": \"\",\n  \"authenticatorFlow\": false,\n  \"requirement\": \"\",\n  \"priority\": 0,\n  \"autheticatorFlow\": false,\n  \"id\": \"\",\n  \"flowId\": \"\",\n  \"parentFlow\": \"\"\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/admin/realms/:realm/authentication/executions') do |req|
  req.body = "{\n  \"authenticatorConfig\": \"\",\n  \"authenticator\": \"\",\n  \"authenticatorFlow\": false,\n  \"requirement\": \"\",\n  \"priority\": 0,\n  \"autheticatorFlow\": false,\n  \"id\": \"\",\n  \"flowId\": \"\",\n  \"parentFlow\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

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

    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 '{
  "authenticatorConfig": "",
  "authenticator": "",
  "authenticatorFlow": false,
  "requirement": "",
  "priority": 0,
  "autheticatorFlow": false,
  "id": "",
  "flowId": "",
  "parentFlow": ""
}' |  \
  http POST {{baseUrl}}/admin/realms/:realm/authentication/executions \
  content-type:application/json

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

import Foundation

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

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

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

require "http/client"

url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/flows/:flowAlias/executions/flow', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/:realm/authentication/flows/:flowAlias/executions/flow", payload, headers)

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

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

import requests

url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/flows/:flowAlias/executions/flow \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - {{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/flows/:flowAlias/copy" {:content-type :json})

require "http/client"

url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/flows/:flowAlias/copy")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/flows/:flowAlias/copy');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/flows/:flowAlias/copy', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/:realm/authentication/flows/:flowAlias/copy", payload, headers)

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

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

import requests

url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/flows/:flowAlias/copy \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - {{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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  \"id\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false,\n  \"builtIn\": false,\n  \"authenticationExecutions\": [\n    {\n      \"authenticatorConfig\": \"\",\n      \"authenticator\": \"\",\n      \"authenticatorFlow\": false,\n      \"requirement\": \"\",\n      \"priority\": 0,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/admin/realms/:realm/authentication/flows"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false,\n  \"builtIn\": false,\n  \"authenticationExecutions\": [\n    {\n      \"authenticatorConfig\": \"\",\n      \"authenticator\": \"\",\n      \"authenticatorFlow\": false,\n      \"requirement\": \"\",\n      \"priority\": 0,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"userSetupAllowed\": false\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}}/admin/realms/:realm/authentication/flows"),
    Content = new StringContent("{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false,\n  \"builtIn\": false,\n  \"authenticationExecutions\": [\n    {\n      \"authenticatorConfig\": \"\",\n      \"authenticator\": \"\",\n      \"authenticatorFlow\": false,\n      \"requirement\": \"\",\n      \"priority\": 0,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"userSetupAllowed\": false\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}}/admin/realms/:realm/authentication/flows");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false,\n  \"builtIn\": false,\n  \"authenticationExecutions\": [\n    {\n      \"authenticatorConfig\": \"\",\n      \"authenticator\": \"\",\n      \"authenticatorFlow\": false,\n      \"requirement\": \"\",\n      \"priority\": 0,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false,\n  \"builtIn\": false,\n  \"authenticationExecutions\": [\n    {\n      \"authenticatorConfig\": \"\",\n      \"authenticator\": \"\",\n      \"authenticatorFlow\": false,\n      \"requirement\": \"\",\n      \"priority\": 0,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"userSetupAllowed\": false\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/admin/realms/:realm/authentication/flows HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 388

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

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/:realm/authentication/flows"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false,\n  \"builtIn\": false,\n  \"authenticationExecutions\": [\n    {\n      \"authenticatorConfig\": \"\",\n      \"authenticator\": \"\",\n      \"authenticatorFlow\": false,\n      \"requirement\": \"\",\n      \"priority\": 0,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"userSetupAllowed\": false\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  \"id\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false,\n  \"builtIn\": false,\n  \"authenticationExecutions\": [\n    {\n      \"authenticatorConfig\": \"\",\n      \"authenticator\": \"\",\n      \"authenticatorFlow\": false,\n      \"requirement\": \"\",\n      \"priority\": 0,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin/realms/:realm/authentication/flows")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

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

const data = JSON.stringify({
  id: '',
  alias: '',
  description: '',
  providerId: '',
  topLevel: false,
  builtIn: false,
  authenticationExecutions: [
    {
      authenticatorConfig: '',
      authenticator: '',
      authenticatorFlow: false,
      requirement: '',
      priority: 0,
      autheticatorFlow: false,
      flowAlias: '',
      userSetupAllowed: 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}}/admin/realms/:realm/authentication/flows');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

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

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

const url = '{{baseUrl}}/admin/realms/:realm/authentication/flows';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"id":"","alias":"","description":"","providerId":"","topLevel":false,"builtIn":false,"authenticationExecutions":[{"authenticatorConfig":"","authenticator":"","authenticatorFlow":false,"requirement":"","priority":0,"autheticatorFlow":false,"flowAlias":"","userSetupAllowed":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}}/admin/realms/:realm/authentication/flows',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "id": "",\n  "alias": "",\n  "description": "",\n  "providerId": "",\n  "topLevel": false,\n  "builtIn": false,\n  "authenticationExecutions": [\n    {\n      "authenticatorConfig": "",\n      "authenticator": "",\n      "authenticatorFlow": false,\n      "requirement": "",\n      "priority": 0,\n      "autheticatorFlow": false,\n      "flowAlias": "",\n      "userSetupAllowed": false\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  \"id\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false,\n  \"builtIn\": false,\n  \"authenticationExecutions\": [\n    {\n      \"authenticatorConfig\": \"\",\n      \"authenticator\": \"\",\n      \"authenticatorFlow\": false,\n      \"requirement\": \"\",\n      \"priority\": 0,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/admin/realms/: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/admin/realms/: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({
  id: '',
  alias: '',
  description: '',
  providerId: '',
  topLevel: false,
  builtIn: false,
  authenticationExecutions: [
    {
      authenticatorConfig: '',
      authenticator: '',
      authenticatorFlow: false,
      requirement: '',
      priority: 0,
      autheticatorFlow: false,
      flowAlias: '',
      userSetupAllowed: false
    }
  ]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/flows',
  headers: {'content-type': 'application/json'},
  body: {
    id: '',
    alias: '',
    description: '',
    providerId: '',
    topLevel: false,
    builtIn: false,
    authenticationExecutions: [
      {
        authenticatorConfig: '',
        authenticator: '',
        authenticatorFlow: false,
        requirement: '',
        priority: 0,
        autheticatorFlow: false,
        flowAlias: '',
        userSetupAllowed: 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}}/admin/realms/:realm/authentication/flows');

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

req.type('json');
req.send({
  id: '',
  alias: '',
  description: '',
  providerId: '',
  topLevel: false,
  builtIn: false,
  authenticationExecutions: [
    {
      authenticatorConfig: '',
      authenticator: '',
      authenticatorFlow: false,
      requirement: '',
      priority: 0,
      autheticatorFlow: false,
      flowAlias: '',
      userSetupAllowed: 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}}/admin/realms/:realm/authentication/flows',
  headers: {'content-type': 'application/json'},
  data: {
    id: '',
    alias: '',
    description: '',
    providerId: '',
    topLevel: false,
    builtIn: false,
    authenticationExecutions: [
      {
        authenticatorConfig: '',
        authenticator: '',
        authenticatorFlow: false,
        requirement: '',
        priority: 0,
        autheticatorFlow: false,
        flowAlias: '',
        userSetupAllowed: false
      }
    ]
  }
};

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

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

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

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

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

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

 "{{baseUrl}}/admin/realms/: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([
    'id' => '',
    'alias' => '',
    'description' => '',
    'providerId' => '',
    'topLevel' => null,
    'builtIn' => null,
    'authenticationExecutions' => [
        [
                'authenticatorConfig' => '',
                'authenticator' => '',
                'authenticatorFlow' => null,
                'requirement' => '',
                'priority' => 0,
                'autheticatorFlow' => null,
                'flowAlias' => '',
                'userSetupAllowed' => 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}}/admin/realms/:realm/authentication/flows', [
  'body' => '{
  "id": "",
  "alias": "",
  "description": "",
  "providerId": "",
  "topLevel": false,
  "builtIn": false,
  "authenticationExecutions": [
    {
      "authenticatorConfig": "",
      "authenticator": "",
      "authenticatorFlow": false,
      "requirement": "",
      "priority": 0,
      "autheticatorFlow": false,
      "flowAlias": "",
      "userSetupAllowed": false
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'id' => '',
  'alias' => '',
  'description' => '',
  'providerId' => '',
  'topLevel' => null,
  'builtIn' => null,
  'authenticationExecutions' => [
    [
        'authenticatorConfig' => '',
        'authenticator' => '',
        'authenticatorFlow' => null,
        'requirement' => '',
        'priority' => 0,
        'autheticatorFlow' => null,
        'flowAlias' => '',
        'userSetupAllowed' => null
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/flows' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "id": "",
  "alias": "",
  "description": "",
  "providerId": "",
  "topLevel": false,
  "builtIn": false,
  "authenticationExecutions": [
    {
      "authenticatorConfig": "",
      "authenticator": "",
      "authenticatorFlow": false,
      "requirement": "",
      "priority": 0,
      "autheticatorFlow": false,
      "flowAlias": "",
      "userSetupAllowed": false
    }
  ]
}'

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

import http.client

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

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

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

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

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

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

import requests

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

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

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

print(response.json())

library(httr)

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

payload <- "{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false,\n  \"builtIn\": false,\n  \"authenticationExecutions\": [\n    {\n      \"authenticatorConfig\": \"\",\n      \"authenticator\": \"\",\n      \"authenticatorFlow\": false,\n      \"requirement\": \"\",\n      \"priority\": 0,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"userSetupAllowed\": false\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}}/admin/realms/: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  \"id\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false,\n  \"builtIn\": false,\n  \"authenticationExecutions\": [\n    {\n      \"authenticatorConfig\": \"\",\n      \"authenticator\": \"\",\n      \"authenticatorFlow\": false,\n      \"requirement\": \"\",\n      \"priority\": 0,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"userSetupAllowed\": false\n    }\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/admin/realms/:realm/authentication/flows') do |req|
  req.body = "{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false,\n  \"builtIn\": false,\n  \"authenticationExecutions\": [\n    {\n      \"authenticatorConfig\": \"\",\n      \"authenticator\": \"\",\n      \"authenticatorFlow\": false,\n      \"requirement\": \"\",\n      \"priority\": 0,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "id": "",
        "alias": "",
        "description": "",
        "providerId": "",
        "topLevel": false,
        "builtIn": false,
        "authenticationExecutions": (
            json!({
                "authenticatorConfig": "",
                "authenticator": "",
                "authenticatorFlow": false,
                "requirement": "",
                "priority": 0,
                "autheticatorFlow": false,
                "flowAlias": "",
                "userSetupAllowed": 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 '{
  "id": "",
  "alias": "",
  "description": "",
  "providerId": "",
  "topLevel": false,
  "builtIn": false,
  "authenticationExecutions": [
    {
      "authenticatorConfig": "",
      "authenticator": "",
      "authenticatorFlow": false,
      "requirement": "",
      "priority": 0,
      "autheticatorFlow": false,
      "flowAlias": "",
      "userSetupAllowed": false
    }
  ]
}' |  \
  http POST {{baseUrl}}/admin/realms/:realm/authentication/flows \
  content-type:application/json

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

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/: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, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin/realms/:realm/authentication/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  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/admin/realms/:realm/authentication/config" {:content-type :json
                                                                                      :form-params {:id ""
                                                                                                    :alias ""
                                                                                                    :config {}}})

require "http/client"

url = "{{baseUrl}}/admin/realms/:realm/authentication/config"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\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}}/admin/realms/:realm/authentication/config"),
    Content = new StringContent("{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\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}}/admin/realms/:realm/authentication/config");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin/realms/:realm/authentication/config"

	payload := strings.NewReader("{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\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/admin/realms/:realm/authentication/config HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 45

{
  "id": "",
  "alias": "",
  "config": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin/realms/:realm/authentication/config")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/:realm/authentication/config"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\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  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin/realms/:realm/authentication/config")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin/realms/:realm/authentication/config")
  .header("content-type", "application/json")
  .body("{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\n}")
  .asString();

const data = JSON.stringify({
  id: '',
  alias: '',
  config: {}
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/config',
  headers: {'content-type': 'application/json'},
  data: {id: '', alias: '', config: {}}
};

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

const url = '{{baseUrl}}/admin/realms/:realm/authentication/config';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"id":"","alias":"","config":{}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/realms/:realm/authentication/config',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "id": "",\n  "alias": "",\n  "config": {}\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/admin/realms/:realm/authentication/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/admin/realms/:realm/authentication/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({id: '', alias: '', config: {}}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/config',
  headers: {'content-type': 'application/json'},
  body: {id: '', alias: '', config: {}},
  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}}/admin/realms/:realm/authentication/config');

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

req.type('json');
req.send({
  id: '',
  alias: '',
  config: {}
});

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}}/admin/realms/:realm/authentication/config',
  headers: {'content-type': 'application/json'},
  data: {id: '', alias: '', config: {}}
};

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

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

const url = '{{baseUrl}}/admin/realms/:realm/authentication/config';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"id":"","alias":"","config":{}}'
};

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 = @{ @"id": @"",
                              @"alias": @"",
                              @"config": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/realms/:realm/authentication/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}}/admin/realms/:realm/authentication/config" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\n}" in

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

 "{{baseUrl}}/admin/realms/:realm/authentication/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([
    'id' => '',
    'alias' => '',
    'config' => [
        
    ]
  ]),
  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}}/admin/realms/:realm/authentication/config', [
  'body' => '{
  "id": "",
  "alias": "",
  "config": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'id' => '',
  'alias' => '',
  'config' => [
    
  ]
]));

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

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

append(json_encode([
  'id' => '',
  'alias' => '',
  'config' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/admin/realms/:realm/authentication/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}}/admin/realms/:realm/authentication/config' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "id": "",
  "alias": "",
  "config": {}
}'

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

import http.client

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

payload = "{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\n}"

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

conn.request("POST", "/baseUrl/admin/realms/:realm/authentication/config", payload, headers)

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

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

import requests

url = "{{baseUrl}}/admin/realms/:realm/authentication/config"

payload = {
    "id": "",
    "alias": "",
    "config": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/:realm/authentication/config"

payload <- "{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\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}}/admin/realms/:realm/authentication/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  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\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/admin/realms/:realm/authentication/config') do |req|
  req.body = "{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "id": "",
        "alias": "",
        "config": 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 '{
  "id": "",
  "alias": "",
  "config": {}
}' |  \
  http POST {{baseUrl}}/admin/realms/:realm/authentication/config \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "id": "",\n  "alias": "",\n  "config": {}\n}' \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/authentication/config

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/:realm/authentication/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, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config")

require "http/client"

url = "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config"

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}}/admin/realms/:realm/authentication/required-actions/:alias/config"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config"

	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/admin/realms/:realm/authentication/required-actions/:alias/config HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config"))
    .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}}/admin/realms/:realm/authentication/required-actions/:alias/config")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config")
  .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}}/admin/realms/:realm/authentication/required-actions/:alias/config');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config'
};

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

const url = '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config';
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}}/admin/realms/:realm/authentication/required-actions/:alias/config',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin/realms/:realm/authentication/required-actions/:alias/config',
  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}}/admin/realms/:realm/authentication/required-actions/:alias/config'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config');

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}}/admin/realms/:realm/authentication/required-actions/:alias/config'
};

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

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

const url = '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config';
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}}/admin/realms/:realm/authentication/required-actions/:alias/config"]
                                                       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}}/admin/realms/:realm/authentication/required-actions/:alias/config" in

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

 "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config",
  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}}/admin/realms/:realm/authentication/required-actions/:alias/config');

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/admin/realms/:realm/authentication/required-actions/:alias/config")

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

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

import requests

url = "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config")

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/admin/realms/:realm/authentication/required-actions/:alias/config') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config";

    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}}/admin/realms/:realm/authentication/required-actions/:alias/config

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config")! 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}}/admin/realms/:realm/authentication/flows/:id");

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/:realm/authentication/flows/:id HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/flows/:id")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/flows/:id');

xhr.send(data);

import axios from 'axios';

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

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

const url = '{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/flows/:id',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/flows/:id" in

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

 "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/flows/:id');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

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

response = requests.delete(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/flows/:id

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

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/config/:id");

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/:realm/authentication/config/:id HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/config/:id")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/config/:id');

xhr.send(data);

import axios from 'axios';

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

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

const url = '{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/config/:id',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/config/:id" in

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

 "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/config/:id');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("DELETE", "/baseUrl/admin/realms/:realm/authentication/config/:id")

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

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

import requests

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

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/:realm/authentication/config/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/config/:id

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

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/executions/:executionId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId")

require "http/client"

url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/:realm/authentication/executions/:executionId HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/executions/:executionId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/executions/:executionId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId'
};

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

const url = '{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/executions/:executionId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/executions/:executionId" in

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

 "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/executions/:executionId');

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId');
$request->setMethod(HTTP_METH_DELETE);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/admin/realms/:realm/authentication/executions/:executionId")

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

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

import requests

url = "{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId"

response = requests.delete(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/executions/:executionId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/required-actions/:alias");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias")

require "http/client"

url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/:realm/authentication/required-actions/:alias HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/required-actions/:alias")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/required-actions/:alias');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias'
};

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

const url = '{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/required-actions/:alias" in

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

 "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/required-actions/:alias');

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/admin/realms/:realm/authentication/required-actions/:alias")

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

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

import requests

url = "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/required-actions/:alias

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/required-actions/:alias/config");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config")

require "http/client"

url = "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config"

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

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

var client = new RestClient("{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config"

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

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

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

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

}

GET /baseUrl/admin/realms/:realm/authentication/required-actions/:alias/config HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config'
};

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

const url = '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin/realms/:realm/authentication/required-actions/:alias/config',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config'
};

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

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

const url = '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config" in

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

 "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config');

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/admin/realms/:realm/authentication/required-actions/:alias/config")

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

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

import requests

url = "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/admin/realms/:realm/authentication/required-actions/:alias/config') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config-description");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config-description")

require "http/client"

url = "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/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}}/admin/realms/:realm/authentication/required-actions/:alias/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}}/admin/realms/:realm/authentication/required-actions/:alias/config-description");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/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/admin/realms/:realm/authentication/required-actions/:alias/config-description HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config-description")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/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}}/admin/realms/:realm/authentication/required-actions/:alias/config-description")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/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}}/admin/realms/:realm/authentication/required-actions/:alias/config-description');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config-description'
};

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

const url = '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/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}}/admin/realms/:realm/authentication/required-actions/:alias/config-description',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/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/admin/realms/:realm/authentication/required-actions/:alias/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}}/admin/realms/:realm/authentication/required-actions/:alias/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}}/admin/realms/:realm/authentication/required-actions/:alias/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}}/admin/realms/:realm/authentication/required-actions/:alias/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}}/admin/realms/:realm/authentication/required-actions/:alias/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}}/admin/realms/:realm/authentication/required-actions/:alias/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}}/admin/realms/:realm/authentication/required-actions/:alias/config-description" in

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

 "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/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}}/admin/realms/:realm/authentication/required-actions/:alias/config-description');

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config-description');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config-description');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config-description' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config-description' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/admin/realms/:realm/authentication/required-actions/:alias/config-description")

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

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

import requests

url = "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config-description"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config-description"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/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/admin/realms/:realm/authentication/required-actions/:alias/config-description') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/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}}/admin/realms/:realm/authentication/required-actions/:alias/config-description

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config-description

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/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}}/admin/realms/:realm/authentication/executions/:executionId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId")

require "http/client"

url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/:realm/authentication/executions/:executionId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/executions/:executionId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/executions/:executionId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId'
};

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

const url = '{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/executions/:executionId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/executions/:executionId" in

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

 "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/executions/:executionId');

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/admin/realms/:realm/authentication/executions/:executionId")

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

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

import requests

url = "{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId"

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/realms/: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/admin/realms/:realm/authentication/executions/:executionId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/executions/:executionId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId

import Foundation

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/admin/realms/:realm/authentication/flows/:flowAlias/executions")

require "http/client"

url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/:realm/authentication/flows/:flowAlias/executions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin/realms/:realm/authentication/flows/:flowAlias/executions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/flows/:flowAlias/executions")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/flows/:flowAlias/executions');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/flows/:flowAlias/executions'
};

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

const url = '{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/flows/:flowAlias/executions" in

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

 "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/flows/:flowAlias/executions');

echo $response->getBody();

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

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

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

setRequestUrl('{{baseUrl}}/admin/realms/:realm/authentication/flows/:flowAlias/executions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/realms/:realm/authentication/flows/:flowAlias/executions' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/authentication/flows/:flowAlias/executions' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/admin/realms/:realm/authentication/flows/:flowAlias/executions")

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

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

import requests

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

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/flows/:flowAlias/executions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/authentication/flows/:flowAlias/executions

import Foundation

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/admin/realms/:realm/authentication/flows/:id")

require "http/client"

url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/:realm/authentication/flows/:id HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/flows/:id")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/flows/:id');

xhr.send(data);

import axios from 'axios';

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

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

const url = '{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/flows/:id',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/flows/:id" in

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

 "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/flows/:id');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/admin/realms/:realm/authentication/flows/:id")

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

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

import requests

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

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/realms/: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/admin/realms/:realm/authentication/flows/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/flows/:id

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

import Foundation

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/admin/realms/:realm/authentication/flows")

require "http/client"

url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/:realm/authentication/flows HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/flows")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/flows');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/flows'
};

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

const url = '{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/flows',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/flows" in

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

 "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/flows');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/realms/:realm/authentication/flows' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/authentication/flows' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/admin/realms/:realm/authentication/flows")

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

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

import requests

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

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/realms/: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/admin/realms/:realm/authentication/flows') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/flows

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/authentication/flows

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/config/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/admin/realms/:realm/authentication/config/:id")

require "http/client"

url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/:realm/authentication/config/:id HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/config/:id")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/config/:id');

xhr.send(data);

import axios from 'axios';

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

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

const url = '{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/config/:id',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/config/:id" in

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

 "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/config/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/:realm/authentication/config/:id');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/realms/:realm/authentication/config/:id' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/authentication/config/:id' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/admin/realms/:realm/authentication/config/:id")

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

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

import requests

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

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/:realm/authentication/config/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/realms/: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/admin/realms/:realm/authentication/config/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/config/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/authentication/config/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/config-description/:providerId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/admin/realms/:realm/authentication/config-description/:providerId")

require "http/client"

url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/:realm/authentication/config-description/:providerId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin/realms/:realm/authentication/config-description/:providerId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/config-description/:providerId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/config-description/:providerId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/config-description/:providerId'
};

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

const url = '{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/config-description/:providerId" in

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

 "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/config-description/:providerId');

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/:realm/authentication/config-description/:providerId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/admin/realms/:realm/authentication/config-description/:providerId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/realms/:realm/authentication/config-description/:providerId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/authentication/config-description/:providerId' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/admin/realms/:realm/authentication/config-description/:providerId")

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

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

import requests

url = "{{baseUrl}}/admin/realms/:realm/authentication/config-description/:providerId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/config-description/:providerId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/authentication/config-description/:providerId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/authenticator-providers");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/admin/realms/:realm/authentication/authenticator-providers")

require "http/client"

url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/:realm/authentication/authenticator-providers HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin/realms/:realm/authentication/authenticator-providers")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/authenticator-providers")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/authenticator-providers');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/authenticator-providers'
};

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

const url = '{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/authenticator-providers',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/authenticator-providers" in

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

 "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/authenticator-providers');

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/:realm/authentication/authenticator-providers');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/admin/realms/:realm/authentication/authenticator-providers');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/realms/:realm/authentication/authenticator-providers' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/authentication/authenticator-providers' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/admin/realms/:realm/authentication/authenticator-providers")

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

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

import requests

url = "{{baseUrl}}/admin/realms/:realm/authentication/authenticator-providers"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/:realm/authentication/authenticator-providers"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/realms/: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/admin/realms/:realm/authentication/authenticator-providers') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/authenticator-providers

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/authentication/authenticator-providers

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/client-authenticator-providers");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/admin/realms/:realm/authentication/client-authenticator-providers")

require "http/client"

url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/:realm/authentication/client-authenticator-providers HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin/realms/:realm/authentication/client-authenticator-providers")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/client-authenticator-providers")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/client-authenticator-providers');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/client-authenticator-providers'
};

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

const url = '{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/client-authenticator-providers" in

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

 "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/client-authenticator-providers');

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/:realm/authentication/client-authenticator-providers');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/admin/realms/:realm/authentication/client-authenticator-providers');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/realms/:realm/authentication/client-authenticator-providers' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/authentication/client-authenticator-providers' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/admin/realms/:realm/authentication/client-authenticator-providers")

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

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

import requests

url = "{{baseUrl}}/admin/realms/:realm/authentication/client-authenticator-providers"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/client-authenticator-providers

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/authentication/client-authenticator-providers

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/per-client-config-description");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/admin/realms/:realm/authentication/per-client-config-description")

require "http/client"

url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/:realm/authentication/per-client-config-description HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin/realms/:realm/authentication/per-client-config-description")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/per-client-config-description")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/per-client-config-description');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/per-client-config-description'
};

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

const url = '{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/per-client-config-description" in

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

 "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/per-client-config-description');

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/per-client-config-description');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/realms/:realm/authentication/per-client-config-description' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/authentication/per-client-config-description' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/admin/realms/:realm/authentication/per-client-config-description")

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

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

import requests

url = "{{baseUrl}}/admin/realms/:realm/authentication/per-client-config-description"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/per-client-config-description

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/authentication/per-client-config-description

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/executions/:executionId/config/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/config/:id")

require "http/client"

url = "{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/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}}/admin/realms/:realm/authentication/executions/:executionId/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}}/admin/realms/:realm/authentication/executions/:executionId/config/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/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/admin/realms/:realm/authentication/executions/:executionId/config/:id HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/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}}/admin/realms/:realm/authentication/executions/:executionId/config/:id")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/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}}/admin/realms/:realm/authentication/executions/:executionId/config/:id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/config/:id'
};

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

const url = '{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/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}}/admin/realms/:realm/authentication/executions/:executionId/config/:id',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/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/admin/realms/:realm/authentication/executions/:executionId/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}}/admin/realms/:realm/authentication/executions/:executionId/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}}/admin/realms/:realm/authentication/executions/:executionId/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}}/admin/realms/:realm/authentication/executions/:executionId/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}}/admin/realms/:realm/authentication/executions/:executionId/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}}/admin/realms/:realm/authentication/executions/:executionId/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}}/admin/realms/:realm/authentication/executions/:executionId/config/:id" in

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

 "{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/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}}/admin/realms/:realm/authentication/executions/:executionId/config/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/config/:id');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/config/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/config/:id' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/config/:id' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/admin/realms/:realm/authentication/executions/:executionId/config/:id")

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

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

import requests

url = "{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/config/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/config/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/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/admin/realms/:realm/authentication/executions/:executionId/config/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/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}}/admin/realms/:realm/authentication/executions/:executionId/config/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/config/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/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}}/admin/realms/:realm/authentication/form-action-providers");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/admin/realms/:realm/authentication/form-action-providers")

require "http/client"

url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/:realm/authentication/form-action-providers HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin/realms/:realm/authentication/form-action-providers")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/form-action-providers")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/form-action-providers');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/form-action-providers'
};

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

const url = '{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/form-action-providers" in

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

 "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/form-action-providers');

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/:realm/authentication/form-action-providers');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/admin/realms/:realm/authentication/form-action-providers');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/realms/:realm/authentication/form-action-providers' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/authentication/form-action-providers' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/admin/realms/:realm/authentication/form-action-providers")

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

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

import requests

url = "{{baseUrl}}/admin/realms/:realm/authentication/form-action-providers"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/form-action-providers

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/authentication/form-action-providers

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/form-providers");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/admin/realms/:realm/authentication/form-providers")

require "http/client"

url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/:realm/authentication/form-providers HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin/realms/:realm/authentication/form-providers")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/form-providers")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/form-providers');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/form-providers'
};

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

const url = '{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/form-providers',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/form-providers" in

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

 "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/form-providers');

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/:realm/authentication/form-providers');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/admin/realms/:realm/authentication/form-providers');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/realms/:realm/authentication/form-providers' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/authentication/form-providers' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/admin/realms/:realm/authentication/form-providers")

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

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

import requests

url = "{{baseUrl}}/admin/realms/:realm/authentication/form-providers"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/:realm/authentication/form-providers"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/realms/: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/admin/realms/:realm/authentication/form-providers') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/form-providers

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/authentication/form-providers

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/required-actions/:alias");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias")

require "http/client"

url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/:realm/authentication/required-actions/:alias HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/required-actions/:alias")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/required-actions/:alias');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias'
};

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

const url = '{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/required-actions/:alias" in

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

 "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/required-actions/:alias');

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/admin/realms/:realm/authentication/required-actions/:alias")

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

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

import requests

url = "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/required-actions/:alias

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/required-actions");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/admin/realms/:realm/authentication/required-actions")

require "http/client"

url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/:realm/authentication/required-actions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin/realms/:realm/authentication/required-actions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/required-actions")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/required-actions');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/required-actions'
};

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

const url = '{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/required-actions',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/required-actions" in

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

 "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/required-actions');

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/:realm/authentication/required-actions');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/admin/realms/:realm/authentication/required-actions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/realms/:realm/authentication/required-actions' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/authentication/required-actions' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/admin/realms/:realm/authentication/required-actions")

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

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

import requests

url = "{{baseUrl}}/admin/realms/:realm/authentication/required-actions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/:realm/authentication/required-actions"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/realms/: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/admin/realms/:realm/authentication/required-actions') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/required-actions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/authentication/required-actions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/unregistered-required-actions");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/admin/realms/:realm/authentication/unregistered-required-actions")

require "http/client"

url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/:realm/authentication/unregistered-required-actions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin/realms/:realm/authentication/unregistered-required-actions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/unregistered-required-actions")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/unregistered-required-actions');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/unregistered-required-actions'
};

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

const url = '{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/unregistered-required-actions" in

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

 "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/unregistered-required-actions');

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/:realm/authentication/unregistered-required-actions');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/admin/realms/:realm/authentication/unregistered-required-actions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/realms/:realm/authentication/unregistered-required-actions' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/authentication/unregistered-required-actions' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/admin/realms/:realm/authentication/unregistered-required-actions")

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

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

import requests

url = "{{baseUrl}}/admin/realms/:realm/authentication/unregistered-required-actions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/unregistered-required-actions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/authentication/unregistered-required-actions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/executions/:executionId/lower-priority");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/lower-priority")

require "http/client"

url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/:realm/authentication/executions/:executionId/lower-priority HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/lower-priority")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/executions/:executionId/lower-priority")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/executions/:executionId/lower-priority');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/lower-priority'
};

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

const url = '{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/executions/:executionId/lower-priority" in

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

 "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/executions/:executionId/lower-priority');

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/executions/:executionId/lower-priority');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/lower-priority' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/lower-priority' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/admin/realms/:realm/authentication/executions/:executionId/lower-priority")

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

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

import requests

url = "{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/lower-priority"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/executions/:executionId/lower-priority

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/lower-priority

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/required-actions/:alias/lower-priority");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/lower-priority")

require "http/client"

url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/:realm/authentication/required-actions/:alias/lower-priority HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/lower-priority")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/required-actions/:alias/lower-priority")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/required-actions/:alias/lower-priority');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/required-actions/:alias/lower-priority" in

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

 "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/required-actions/:alias/lower-priority');

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/required-actions/:alias/lower-priority' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/lower-priority' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/admin/realms/:realm/authentication/required-actions/:alias/lower-priority")

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

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

import requests

url = "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/lower-priority"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/required-actions/:alias/lower-priority

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/lower-priority

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/executions/:executionId/raise-priority");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/raise-priority")

require "http/client"

url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/:realm/authentication/executions/:executionId/raise-priority HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/raise-priority")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/executions/:executionId/raise-priority")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/executions/:executionId/raise-priority');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/raise-priority'
};

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

const url = '{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/executions/:executionId/raise-priority" in

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

 "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/executions/:executionId/raise-priority');

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/executions/:executionId/raise-priority');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/raise-priority' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/raise-priority' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/admin/realms/:realm/authentication/executions/:executionId/raise-priority")

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

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

import requests

url = "{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/raise-priority"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/executions/:executionId/raise-priority

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/raise-priority

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/required-actions/:alias/raise-priority");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/raise-priority")

require "http/client"

url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/:realm/authentication/required-actions/:alias/raise-priority HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/raise-priority")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/required-actions/:alias/raise-priority")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/required-actions/:alias/raise-priority');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/required-actions/:alias/raise-priority" in

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

 "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/required-actions/:alias/raise-priority');

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/required-actions/:alias/raise-priority' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/raise-priority' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/admin/realms/:realm/authentication/required-actions/:alias/raise-priority")

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

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

import requests

url = "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/raise-priority"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/required-actions/:alias/raise-priority

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/raise-priority

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/register-required-action" {:content-type :json})

require "http/client"

url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/register-required-action")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/register-required-action');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/register-required-action', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/:realm/authentication/register-required-action", payload, headers)

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

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

import requests

url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/register-required-action \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - {{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/authentication/required-actions/:alias/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  \"config\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config" {:content-type :json
                                                                                                             :form-params {:config {}}})

require "http/client"

url = "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"config\": {}\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}}/admin/realms/:realm/authentication/required-actions/:alias/config"),
    Content = new StringContent("{\n  \"config\": {}\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}}/admin/realms/:realm/authentication/required-actions/:alias/config");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"config\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config"

	payload := strings.NewReader("{\n  \"config\": {}\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/admin/realms/:realm/authentication/required-actions/:alias/config HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 18

{
  "config": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"config\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"config\": {}\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  \"config\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config")
  .header("content-type", "application/json")
  .body("{\n  \"config\": {}\n}")
  .asString();

const data = JSON.stringify({
  config: {}
});

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

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

xhr.open('PUT', '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config',
  headers: {'content-type': 'application/json'},
  data: {config: {}}
};

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

const url = '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"config":{}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "config": {}\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"config\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config")
  .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/admin/realms/:realm/authentication/required-actions/:alias/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({config: {}}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config',
  headers: {'content-type': 'application/json'},
  body: {config: {}},
  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}}/admin/realms/:realm/authentication/required-actions/:alias/config');

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

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

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}}/admin/realms/:realm/authentication/required-actions/:alias/config',
  headers: {'content-type': 'application/json'},
  data: {config: {}}
};

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

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

const url = '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"config":{}}'
};

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 = @{ @"config": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config"]
                                                       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}}/admin/realms/:realm/authentication/required-actions/:alias/config" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"config\": {}\n}" in

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

 "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config",
  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([
    'config' => [
        
    ]
  ]),
  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}}/admin/realms/:realm/authentication/required-actions/:alias/config', [
  'body' => '{
  "config": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config');
$request->setMethod(HTTP_METH_PUT);

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

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

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

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

append(json_encode([
  'config' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config');
$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}}/admin/realms/:realm/authentication/required-actions/:alias/config' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "config": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "config": {}
}'

import http.client

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

payload = "{\n  \"config\": {}\n}"

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

conn.request("PUT", "/baseUrl/admin/realms/:realm/authentication/required-actions/:alias/config", payload, headers)

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

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

import requests

url = "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config"

payload <- "{\n  \"config\": {}\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}}/admin/realms/:realm/authentication/required-actions/:alias/config")

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  \"config\": {}\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/admin/realms/:realm/authentication/required-actions/:alias/config') do |req|
  req.body = "{\n  \"config\": {}\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}}/admin/realms/:realm/authentication/required-actions/:alias/config";

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

    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 '{
  "config": {}
}' |  \
  http PUT {{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "config": {}\n}' \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias/config")! 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}}/admin/realms/: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  \"id\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false,\n  \"builtIn\": false,\n  \"authenticationExecutions\": [\n    {\n      \"authenticatorConfig\": \"\",\n      \"authenticator\": \"\",\n      \"authenticatorFlow\": false,\n      \"requirement\": \"\",\n      \"priority\": 0,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/admin/realms/:realm/authentication/flows/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false,\n  \"builtIn\": false,\n  \"authenticationExecutions\": [\n    {\n      \"authenticatorConfig\": \"\",\n      \"authenticator\": \"\",\n      \"authenticatorFlow\": false,\n      \"requirement\": \"\",\n      \"priority\": 0,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ]\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}}/admin/realms/:realm/authentication/flows/:id"),
    Content = new StringContent("{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false,\n  \"builtIn\": false,\n  \"authenticationExecutions\": [\n    {\n      \"authenticatorConfig\": \"\",\n      \"authenticator\": \"\",\n      \"authenticatorFlow\": false,\n      \"requirement\": \"\",\n      \"priority\": 0,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"userSetupAllowed\": false\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}}/admin/realms/:realm/authentication/flows/:id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false,\n  \"builtIn\": false,\n  \"authenticationExecutions\": [\n    {\n      \"authenticatorConfig\": \"\",\n      \"authenticator\": \"\",\n      \"authenticatorFlow\": false,\n      \"requirement\": \"\",\n      \"priority\": 0,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false,\n  \"builtIn\": false,\n  \"authenticationExecutions\": [\n    {\n      \"authenticatorConfig\": \"\",\n      \"authenticator\": \"\",\n      \"authenticatorFlow\": false,\n      \"requirement\": \"\",\n      \"priority\": 0,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ]\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/admin/realms/:realm/authentication/flows/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 388

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

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/:realm/authentication/flows/:id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false,\n  \"builtIn\": false,\n  \"authenticationExecutions\": [\n    {\n      \"authenticatorConfig\": \"\",\n      \"authenticator\": \"\",\n      \"authenticatorFlow\": false,\n      \"requirement\": \"\",\n      \"priority\": 0,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"userSetupAllowed\": false\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  \"id\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false,\n  \"builtIn\": false,\n  \"authenticationExecutions\": [\n    {\n      \"authenticatorConfig\": \"\",\n      \"authenticator\": \"\",\n      \"authenticatorFlow\": false,\n      \"requirement\": \"\",\n      \"priority\": 0,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin/realms/:realm/authentication/flows/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

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

const data = JSON.stringify({
  id: '',
  alias: '',
  description: '',
  providerId: '',
  topLevel: false,
  builtIn: false,
  authenticationExecutions: [
    {
      authenticatorConfig: '',
      authenticator: '',
      authenticatorFlow: false,
      requirement: '',
      priority: 0,
      autheticatorFlow: false,
      flowAlias: '',
      userSetupAllowed: 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}}/admin/realms/:realm/authentication/flows/:id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

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

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

const url = '{{baseUrl}}/admin/realms/:realm/authentication/flows/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"id":"","alias":"","description":"","providerId":"","topLevel":false,"builtIn":false,"authenticationExecutions":[{"authenticatorConfig":"","authenticator":"","authenticatorFlow":false,"requirement":"","priority":0,"autheticatorFlow":false,"flowAlias":"","userSetupAllowed":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}}/admin/realms/:realm/authentication/flows/:id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "id": "",\n  "alias": "",\n  "description": "",\n  "providerId": "",\n  "topLevel": false,\n  "builtIn": false,\n  "authenticationExecutions": [\n    {\n      "authenticatorConfig": "",\n      "authenticator": "",\n      "authenticatorFlow": false,\n      "requirement": "",\n      "priority": 0,\n      "autheticatorFlow": false,\n      "flowAlias": "",\n      "userSetupAllowed": false\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  \"id\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false,\n  \"builtIn\": false,\n  \"authenticationExecutions\": [\n    {\n      \"authenticatorConfig\": \"\",\n      \"authenticator\": \"\",\n      \"authenticatorFlow\": false,\n      \"requirement\": \"\",\n      \"priority\": 0,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/admin/realms/: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/admin/realms/: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({
  id: '',
  alias: '',
  description: '',
  providerId: '',
  topLevel: false,
  builtIn: false,
  authenticationExecutions: [
    {
      authenticatorConfig: '',
      authenticator: '',
      authenticatorFlow: false,
      requirement: '',
      priority: 0,
      autheticatorFlow: false,
      flowAlias: '',
      userSetupAllowed: false
    }
  ]
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/flows/:id',
  headers: {'content-type': 'application/json'},
  body: {
    id: '',
    alias: '',
    description: '',
    providerId: '',
    topLevel: false,
    builtIn: false,
    authenticationExecutions: [
      {
        authenticatorConfig: '',
        authenticator: '',
        authenticatorFlow: false,
        requirement: '',
        priority: 0,
        autheticatorFlow: false,
        flowAlias: '',
        userSetupAllowed: 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}}/admin/realms/:realm/authentication/flows/:id');

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

req.type('json');
req.send({
  id: '',
  alias: '',
  description: '',
  providerId: '',
  topLevel: false,
  builtIn: false,
  authenticationExecutions: [
    {
      authenticatorConfig: '',
      authenticator: '',
      authenticatorFlow: false,
      requirement: '',
      priority: 0,
      autheticatorFlow: false,
      flowAlias: '',
      userSetupAllowed: 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}}/admin/realms/:realm/authentication/flows/:id',
  headers: {'content-type': 'application/json'},
  data: {
    id: '',
    alias: '',
    description: '',
    providerId: '',
    topLevel: false,
    builtIn: false,
    authenticationExecutions: [
      {
        authenticatorConfig: '',
        authenticator: '',
        authenticatorFlow: false,
        requirement: '',
        priority: 0,
        autheticatorFlow: false,
        flowAlias: '',
        userSetupAllowed: false
      }
    ]
  }
};

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

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

const url = '{{baseUrl}}/admin/realms/:realm/authentication/flows/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"id":"","alias":"","description":"","providerId":"","topLevel":false,"builtIn":false,"authenticationExecutions":[{"authenticatorConfig":"","authenticator":"","authenticatorFlow":false,"requirement":"","priority":0,"autheticatorFlow":false,"flowAlias":"","userSetupAllowed":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 = @{ @"id": @"",
                              @"alias": @"",
                              @"description": @"",
                              @"providerId": @"",
                              @"topLevel": @NO,
                              @"builtIn": @NO,
                              @"authenticationExecutions": @[ @{ @"authenticatorConfig": @"", @"authenticator": @"", @"authenticatorFlow": @NO, @"requirement": @"", @"priority": @0, @"autheticatorFlow": @NO, @"flowAlias": @"", @"userSetupAllowed": @NO } ] };

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

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

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

 "{{baseUrl}}/admin/realms/: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([
    'id' => '',
    'alias' => '',
    'description' => '',
    'providerId' => '',
    'topLevel' => null,
    'builtIn' => null,
    'authenticationExecutions' => [
        [
                'authenticatorConfig' => '',
                'authenticator' => '',
                'authenticatorFlow' => null,
                'requirement' => '',
                'priority' => 0,
                'autheticatorFlow' => null,
                'flowAlias' => '',
                'userSetupAllowed' => 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}}/admin/realms/:realm/authentication/flows/:id', [
  'body' => '{
  "id": "",
  "alias": "",
  "description": "",
  "providerId": "",
  "topLevel": false,
  "builtIn": false,
  "authenticationExecutions": [
    {
      "authenticatorConfig": "",
      "authenticator": "",
      "authenticatorFlow": false,
      "requirement": "",
      "priority": 0,
      "autheticatorFlow": false,
      "flowAlias": "",
      "userSetupAllowed": false
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'id' => '',
  'alias' => '',
  'description' => '',
  'providerId' => '',
  'topLevel' => null,
  'builtIn' => null,
  'authenticationExecutions' => [
    [
        'authenticatorConfig' => '',
        'authenticator' => '',
        'authenticatorFlow' => null,
        'requirement' => '',
        'priority' => 0,
        'autheticatorFlow' => null,
        'flowAlias' => '',
        'userSetupAllowed' => null
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/flows/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "id": "",
  "alias": "",
  "description": "",
  "providerId": "",
  "topLevel": false,
  "builtIn": false,
  "authenticationExecutions": [
    {
      "authenticatorConfig": "",
      "authenticator": "",
      "authenticatorFlow": false,
      "requirement": "",
      "priority": 0,
      "autheticatorFlow": false,
      "flowAlias": "",
      "userSetupAllowed": false
    }
  ]
}'

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

import http.client

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

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

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

conn.request("PUT", "/baseUrl/admin/realms/:realm/authentication/flows/:id", payload, headers)

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

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

import requests

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

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

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

print(response.json())

library(httr)

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

payload <- "{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false,\n  \"builtIn\": false,\n  \"authenticationExecutions\": [\n    {\n      \"authenticatorConfig\": \"\",\n      \"authenticator\": \"\",\n      \"authenticatorFlow\": false,\n      \"requirement\": \"\",\n      \"priority\": 0,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"userSetupAllowed\": false\n    }\n  ]\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}}/admin/realms/: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  \"id\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false,\n  \"builtIn\": false,\n  \"authenticationExecutions\": [\n    {\n      \"authenticatorConfig\": \"\",\n      \"authenticator\": \"\",\n      \"authenticatorFlow\": false,\n      \"requirement\": \"\",\n      \"priority\": 0,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"userSetupAllowed\": false\n    }\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.put('/baseUrl/admin/realms/:realm/authentication/flows/:id') do |req|
  req.body = "{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"providerId\": \"\",\n  \"topLevel\": false,\n  \"builtIn\": false,\n  \"authenticationExecutions\": [\n    {\n      \"authenticatorConfig\": \"\",\n      \"authenticator\": \"\",\n      \"authenticatorFlow\": false,\n      \"requirement\": \"\",\n      \"priority\": 0,\n      \"autheticatorFlow\": false,\n      \"flowAlias\": \"\",\n      \"userSetupAllowed\": false\n    }\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}}/admin/realms/:realm/authentication/flows/:id";

    let payload = json!({
        "id": "",
        "alias": "",
        "description": "",
        "providerId": "",
        "topLevel": false,
        "builtIn": false,
        "authenticationExecutions": (
            json!({
                "authenticatorConfig": "",
                "authenticator": "",
                "authenticatorFlow": false,
                "requirement": "",
                "priority": 0,
                "autheticatorFlow": false,
                "flowAlias": "",
                "userSetupAllowed": 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 '{
  "id": "",
  "alias": "",
  "description": "",
  "providerId": "",
  "topLevel": false,
  "builtIn": false,
  "authenticationExecutions": [
    {
      "authenticatorConfig": "",
      "authenticator": "",
      "authenticatorFlow": false,
      "requirement": "",
      "priority": 0,
      "autheticatorFlow": false,
      "flowAlias": "",
      "userSetupAllowed": false
    }
  ]
}' |  \
  http PUT {{baseUrl}}/admin/realms/:realm/authentication/flows/:id \
  content-type:application/json

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

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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  \"id\": \"\",\n  \"requirement\": \"\",\n  \"displayName\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"requirementChoices\": [],\n  \"configurable\": false,\n  \"authenticationFlow\": false,\n  \"providerId\": \"\",\n  \"authenticationConfig\": \"\",\n  \"flowId\": \"\",\n  \"level\": 0,\n  \"index\": 0,\n  \"priority\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/admin/realms/:realm/authentication/flows/:flowAlias/executions" {:content-type :json
                                                                                                          :form-params {:id ""
                                                                                                                        :requirement ""
                                                                                                                        :displayName ""
                                                                                                                        :alias ""
                                                                                                                        :description ""
                                                                                                                        :requirementChoices []
                                                                                                                        :configurable false
                                                                                                                        :authenticationFlow false
                                                                                                                        :providerId ""
                                                                                                                        :authenticationConfig ""
                                                                                                                        :flowId ""
                                                                                                                        :level 0
                                                                                                                        :index 0
                                                                                                                        :priority 0}})

require "http/client"

url = "{{baseUrl}}/admin/realms/:realm/authentication/flows/:flowAlias/executions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"id\": \"\",\n  \"requirement\": \"\",\n  \"displayName\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"requirementChoices\": [],\n  \"configurable\": false,\n  \"authenticationFlow\": false,\n  \"providerId\": \"\",\n  \"authenticationConfig\": \"\",\n  \"flowId\": \"\",\n  \"level\": 0,\n  \"index\": 0,\n  \"priority\": 0\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}}/admin/realms/:realm/authentication/flows/:flowAlias/executions"),
    Content = new StringContent("{\n  \"id\": \"\",\n  \"requirement\": \"\",\n  \"displayName\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"requirementChoices\": [],\n  \"configurable\": false,\n  \"authenticationFlow\": false,\n  \"providerId\": \"\",\n  \"authenticationConfig\": \"\",\n  \"flowId\": \"\",\n  \"level\": 0,\n  \"index\": 0,\n  \"priority\": 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}}/admin/realms/:realm/authentication/flows/:flowAlias/executions");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"id\": \"\",\n  \"requirement\": \"\",\n  \"displayName\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"requirementChoices\": [],\n  \"configurable\": false,\n  \"authenticationFlow\": false,\n  \"providerId\": \"\",\n  \"authenticationConfig\": \"\",\n  \"flowId\": \"\",\n  \"level\": 0,\n  \"index\": 0,\n  \"priority\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"id\": \"\",\n  \"requirement\": \"\",\n  \"displayName\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"requirementChoices\": [],\n  \"configurable\": false,\n  \"authenticationFlow\": false,\n  \"providerId\": \"\",\n  \"authenticationConfig\": \"\",\n  \"flowId\": \"\",\n  \"level\": 0,\n  \"index\": 0,\n  \"priority\": 0\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/admin/realms/:realm/authentication/flows/:flowAlias/executions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 287

{
  "id": "",
  "requirement": "",
  "displayName": "",
  "alias": "",
  "description": "",
  "requirementChoices": [],
  "configurable": false,
  "authenticationFlow": false,
  "providerId": "",
  "authenticationConfig": "",
  "flowId": "",
  "level": 0,
  "index": 0,
  "priority": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/admin/realms/:realm/authentication/flows/:flowAlias/executions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"id\": \"\",\n  \"requirement\": \"\",\n  \"displayName\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"requirementChoices\": [],\n  \"configurable\": false,\n  \"authenticationFlow\": false,\n  \"providerId\": \"\",\n  \"authenticationConfig\": \"\",\n  \"flowId\": \"\",\n  \"level\": 0,\n  \"index\": 0,\n  \"priority\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/:realm/authentication/flows/:flowAlias/executions"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"id\": \"\",\n  \"requirement\": \"\",\n  \"displayName\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"requirementChoices\": [],\n  \"configurable\": false,\n  \"authenticationFlow\": false,\n  \"providerId\": \"\",\n  \"authenticationConfig\": \"\",\n  \"flowId\": \"\",\n  \"level\": 0,\n  \"index\": 0,\n  \"priority\": 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  \"id\": \"\",\n  \"requirement\": \"\",\n  \"displayName\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"requirementChoices\": [],\n  \"configurable\": false,\n  \"authenticationFlow\": false,\n  \"providerId\": \"\",\n  \"authenticationConfig\": \"\",\n  \"flowId\": \"\",\n  \"level\": 0,\n  \"index\": 0,\n  \"priority\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin/realms/:realm/authentication/flows/:flowAlias/executions")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/admin/realms/:realm/authentication/flows/:flowAlias/executions")
  .header("content-type", "application/json")
  .body("{\n  \"id\": \"\",\n  \"requirement\": \"\",\n  \"displayName\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"requirementChoices\": [],\n  \"configurable\": false,\n  \"authenticationFlow\": false,\n  \"providerId\": \"\",\n  \"authenticationConfig\": \"\",\n  \"flowId\": \"\",\n  \"level\": 0,\n  \"index\": 0,\n  \"priority\": 0\n}")
  .asString();

const data = JSON.stringify({
  id: '',
  requirement: '',
  displayName: '',
  alias: '',
  description: '',
  requirementChoices: [],
  configurable: false,
  authenticationFlow: false,
  providerId: '',
  authenticationConfig: '',
  flowId: '',
  level: 0,
  index: 0,
  priority: 0
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/flows/:flowAlias/executions',
  headers: {'content-type': 'application/json'},
  data: {
    id: '',
    requirement: '',
    displayName: '',
    alias: '',
    description: '',
    requirementChoices: [],
    configurable: false,
    authenticationFlow: false,
    providerId: '',
    authenticationConfig: '',
    flowId: '',
    level: 0,
    index: 0,
    priority: 0
  }
};

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

const url = '{{baseUrl}}/admin/realms/:realm/authentication/flows/:flowAlias/executions';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"id":"","requirement":"","displayName":"","alias":"","description":"","requirementChoices":[],"configurable":false,"authenticationFlow":false,"providerId":"","authenticationConfig":"","flowId":"","level":0,"index":0,"priority":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}}/admin/realms/:realm/authentication/flows/:flowAlias/executions',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "id": "",\n  "requirement": "",\n  "displayName": "",\n  "alias": "",\n  "description": "",\n  "requirementChoices": [],\n  "configurable": false,\n  "authenticationFlow": false,\n  "providerId": "",\n  "authenticationConfig": "",\n  "flowId": "",\n  "level": 0,\n  "index": 0,\n  "priority": 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  \"id\": \"\",\n  \"requirement\": \"\",\n  \"displayName\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"requirementChoices\": [],\n  \"configurable\": false,\n  \"authenticationFlow\": false,\n  \"providerId\": \"\",\n  \"authenticationConfig\": \"\",\n  \"flowId\": \"\",\n  \"level\": 0,\n  \"index\": 0,\n  \"priority\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/admin/realms/: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/admin/realms/: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({
  id: '',
  requirement: '',
  displayName: '',
  alias: '',
  description: '',
  requirementChoices: [],
  configurable: false,
  authenticationFlow: false,
  providerId: '',
  authenticationConfig: '',
  flowId: '',
  level: 0,
  index: 0,
  priority: 0
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/flows/:flowAlias/executions',
  headers: {'content-type': 'application/json'},
  body: {
    id: '',
    requirement: '',
    displayName: '',
    alias: '',
    description: '',
    requirementChoices: [],
    configurable: false,
    authenticationFlow: false,
    providerId: '',
    authenticationConfig: '',
    flowId: '',
    level: 0,
    index: 0,
    priority: 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('PUT', '{{baseUrl}}/admin/realms/:realm/authentication/flows/:flowAlias/executions');

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

req.type('json');
req.send({
  id: '',
  requirement: '',
  displayName: '',
  alias: '',
  description: '',
  requirementChoices: [],
  configurable: false,
  authenticationFlow: false,
  providerId: '',
  authenticationConfig: '',
  flowId: '',
  level: 0,
  index: 0,
  priority: 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: 'PUT',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/flows/:flowAlias/executions',
  headers: {'content-type': 'application/json'},
  data: {
    id: '',
    requirement: '',
    displayName: '',
    alias: '',
    description: '',
    requirementChoices: [],
    configurable: false,
    authenticationFlow: false,
    providerId: '',
    authenticationConfig: '',
    flowId: '',
    level: 0,
    index: 0,
    priority: 0
  }
};

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

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

const url = '{{baseUrl}}/admin/realms/:realm/authentication/flows/:flowAlias/executions';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"id":"","requirement":"","displayName":"","alias":"","description":"","requirementChoices":[],"configurable":false,"authenticationFlow":false,"providerId":"","authenticationConfig":"","flowId":"","level":0,"index":0,"priority":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 = @{ @"id": @"",
                              @"requirement": @"",
                              @"displayName": @"",
                              @"alias": @"",
                              @"description": @"",
                              @"requirementChoices": @[  ],
                              @"configurable": @NO,
                              @"authenticationFlow": @NO,
                              @"providerId": @"",
                              @"authenticationConfig": @"",
                              @"flowId": @"",
                              @"level": @0,
                              @"index": @0,
                              @"priority": @0 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/realms/: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}}/admin/realms/: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  \"id\": \"\",\n  \"requirement\": \"\",\n  \"displayName\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"requirementChoices\": [],\n  \"configurable\": false,\n  \"authenticationFlow\": false,\n  \"providerId\": \"\",\n  \"authenticationConfig\": \"\",\n  \"flowId\": \"\",\n  \"level\": 0,\n  \"index\": 0,\n  \"priority\": 0\n}" in

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

 "{{baseUrl}}/admin/realms/: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([
    'id' => '',
    'requirement' => '',
    'displayName' => '',
    'alias' => '',
    'description' => '',
    'requirementChoices' => [
        
    ],
    'configurable' => null,
    'authenticationFlow' => null,
    'providerId' => '',
    'authenticationConfig' => '',
    'flowId' => '',
    'level' => 0,
    'index' => 0,
    'priority' => 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('PUT', '{{baseUrl}}/admin/realms/:realm/authentication/flows/:flowAlias/executions', [
  'body' => '{
  "id": "",
  "requirement": "",
  "displayName": "",
  "alias": "",
  "description": "",
  "requirementChoices": [],
  "configurable": false,
  "authenticationFlow": false,
  "providerId": "",
  "authenticationConfig": "",
  "flowId": "",
  "level": 0,
  "index": 0,
  "priority": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'id' => '',
  'requirement' => '',
  'displayName' => '',
  'alias' => '',
  'description' => '',
  'requirementChoices' => [
    
  ],
  'configurable' => null,
  'authenticationFlow' => null,
  'providerId' => '',
  'authenticationConfig' => '',
  'flowId' => '',
  'level' => 0,
  'index' => 0,
  'priority' => 0
]));

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

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

append(json_encode([
  'id' => '',
  'requirement' => '',
  'displayName' => '',
  'alias' => '',
  'description' => '',
  'requirementChoices' => [
    
  ],
  'configurable' => null,
  'authenticationFlow' => null,
  'providerId' => '',
  'authenticationConfig' => '',
  'flowId' => '',
  'level' => 0,
  'index' => 0,
  'priority' => 0
]));
$request->setRequestUrl('{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/flows/:flowAlias/executions' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "id": "",
  "requirement": "",
  "displayName": "",
  "alias": "",
  "description": "",
  "requirementChoices": [],
  "configurable": false,
  "authenticationFlow": false,
  "providerId": "",
  "authenticationConfig": "",
  "flowId": "",
  "level": 0,
  "index": 0,
  "priority": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/authentication/flows/:flowAlias/executions' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "id": "",
  "requirement": "",
  "displayName": "",
  "alias": "",
  "description": "",
  "requirementChoices": [],
  "configurable": false,
  "authenticationFlow": false,
  "providerId": "",
  "authenticationConfig": "",
  "flowId": "",
  "level": 0,
  "index": 0,
  "priority": 0
}'

import http.client

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

payload = "{\n  \"id\": \"\",\n  \"requirement\": \"\",\n  \"displayName\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"requirementChoices\": [],\n  \"configurable\": false,\n  \"authenticationFlow\": false,\n  \"providerId\": \"\",\n  \"authenticationConfig\": \"\",\n  \"flowId\": \"\",\n  \"level\": 0,\n  \"index\": 0,\n  \"priority\": 0\n}"

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

conn.request("PUT", "/baseUrl/admin/realms/:realm/authentication/flows/:flowAlias/executions", payload, headers)

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

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

import requests

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

payload = {
    "id": "",
    "requirement": "",
    "displayName": "",
    "alias": "",
    "description": "",
    "requirementChoices": [],
    "configurable": False,
    "authenticationFlow": False,
    "providerId": "",
    "authenticationConfig": "",
    "flowId": "",
    "level": 0,
    "index": 0,
    "priority": 0
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"id\": \"\",\n  \"requirement\": \"\",\n  \"displayName\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"requirementChoices\": [],\n  \"configurable\": false,\n  \"authenticationFlow\": false,\n  \"providerId\": \"\",\n  \"authenticationConfig\": \"\",\n  \"flowId\": \"\",\n  \"level\": 0,\n  \"index\": 0,\n  \"priority\": 0\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}}/admin/realms/: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  \"id\": \"\",\n  \"requirement\": \"\",\n  \"displayName\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"requirementChoices\": [],\n  \"configurable\": false,\n  \"authenticationFlow\": false,\n  \"providerId\": \"\",\n  \"authenticationConfig\": \"\",\n  \"flowId\": \"\",\n  \"level\": 0,\n  \"index\": 0,\n  \"priority\": 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.put('/baseUrl/admin/realms/:realm/authentication/flows/:flowAlias/executions') do |req|
  req.body = "{\n  \"id\": \"\",\n  \"requirement\": \"\",\n  \"displayName\": \"\",\n  \"alias\": \"\",\n  \"description\": \"\",\n  \"requirementChoices\": [],\n  \"configurable\": false,\n  \"authenticationFlow\": false,\n  \"providerId\": \"\",\n  \"authenticationConfig\": \"\",\n  \"flowId\": \"\",\n  \"level\": 0,\n  \"index\": 0,\n  \"priority\": 0\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}}/admin/realms/:realm/authentication/flows/:flowAlias/executions";

    let payload = json!({
        "id": "",
        "requirement": "",
        "displayName": "",
        "alias": "",
        "description": "",
        "requirementChoices": (),
        "configurable": false,
        "authenticationFlow": false,
        "providerId": "",
        "authenticationConfig": "",
        "flowId": "",
        "level": 0,
        "index": 0,
        "priority": 0
    });

    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 '{
  "id": "",
  "requirement": "",
  "displayName": "",
  "alias": "",
  "description": "",
  "requirementChoices": [],
  "configurable": false,
  "authenticationFlow": false,
  "providerId": "",
  "authenticationConfig": "",
  "flowId": "",
  "level": 0,
  "index": 0,
  "priority": 0
}' |  \
  http PUT {{baseUrl}}/admin/realms/:realm/authentication/flows/:flowAlias/executions \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "id": "",\n  "requirement": "",\n  "displayName": "",\n  "alias": "",\n  "description": "",\n  "requirementChoices": [],\n  "configurable": false,\n  "authenticationFlow": false,\n  "providerId": "",\n  "authenticationConfig": "",\n  "flowId": "",\n  "level": 0,\n  "index": 0,\n  "priority": 0\n}' \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/authentication/flows/:flowAlias/executions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "id": "",
  "requirement": "",
  "displayName": "",
  "alias": "",
  "description": "",
  "requirementChoices": [],
  "configurable": false,
  "authenticationFlow": false,
  "providerId": "",
  "authenticationConfig": "",
  "flowId": "",
  "level": 0,
  "index": 0,
  "priority": 0
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/admin/realms/:realm/authentication/config/:id" {:content-type :json
                                                                                         :form-params {:id ""
                                                                                                       :alias ""
                                                                                                       :config {}}})

require "http/client"

url = "{{baseUrl}}/admin/realms/:realm/authentication/config/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\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}}/admin/realms/:realm/authentication/config/:id"),
    Content = new StringContent("{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\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}}/admin/realms/:realm/authentication/config/:id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\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/admin/realms/:realm/authentication/config/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 45

{
  "id": "",
  "alias": "",
  "config": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/admin/realms/:realm/authentication/config/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/:realm/authentication/config/:id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\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  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin/realms/:realm/authentication/config/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/admin/realms/:realm/authentication/config/:id")
  .header("content-type", "application/json")
  .body("{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\n}")
  .asString();

const data = JSON.stringify({
  id: '',
  alias: '',
  config: {}
});

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

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

xhr.open('PUT', '{{baseUrl}}/admin/realms/:realm/authentication/config/:id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/config/:id',
  headers: {'content-type': 'application/json'},
  data: {id: '', alias: '', config: {}}
};

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

const url = '{{baseUrl}}/admin/realms/:realm/authentication/config/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"id":"","alias":"","config":{}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/realms/:realm/authentication/config/:id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "id": "",\n  "alias": "",\n  "config": {}\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/admin/realms/: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/admin/realms/: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({id: '', alias: '', config: {}}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/config/:id',
  headers: {'content-type': 'application/json'},
  body: {id: '', alias: '', config: {}},
  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}}/admin/realms/:realm/authentication/config/:id');

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

req.type('json');
req.send({
  id: '',
  alias: '',
  config: {}
});

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}}/admin/realms/:realm/authentication/config/:id',
  headers: {'content-type': 'application/json'},
  data: {id: '', alias: '', config: {}}
};

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

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

const url = '{{baseUrl}}/admin/realms/:realm/authentication/config/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"id":"","alias":"","config":{}}'
};

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 = @{ @"id": @"",
                              @"alias": @"",
                              @"config": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/config/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\n}" in

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

 "{{baseUrl}}/admin/realms/: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([
    'id' => '',
    'alias' => '',
    'config' => [
        
    ]
  ]),
  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}}/admin/realms/:realm/authentication/config/:id', [
  'body' => '{
  "id": "",
  "alias": "",
  "config": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/:realm/authentication/config/:id');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'id' => '',
  'alias' => '',
  'config' => [
    
  ]
]));

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

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

append(json_encode([
  'id' => '',
  'alias' => '',
  'config' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/config/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "id": "",
  "alias": "",
  "config": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/authentication/config/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "id": "",
  "alias": "",
  "config": {}
}'

import http.client

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

payload = "{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\n}"

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

conn.request("PUT", "/baseUrl/admin/realms/:realm/authentication/config/:id", payload, headers)

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

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

import requests

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

payload = {
    "id": "",
    "alias": "",
    "config": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/:realm/authentication/config/:id"

payload <- "{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\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}}/admin/realms/: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  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\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/admin/realms/:realm/authentication/config/:id') do |req|
  req.body = "{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\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}}/admin/realms/:realm/authentication/config/:id";

    let payload = json!({
        "id": "",
        "alias": "",
        "config": json!({})
    });

    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 '{
  "id": "",
  "alias": "",
  "config": {}
}' |  \
  http PUT {{baseUrl}}/admin/realms/:realm/authentication/config/:id \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "id": "",\n  "alias": "",\n  "config": {}\n}' \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/authentication/config/:id

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/config" {:content-type :json
                                                                                                              :form-params {:id ""
                                                                                                                            :alias ""
                                                                                                                            :config {}}})

require "http/client"

url = "{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/config"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\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}}/admin/realms/:realm/authentication/executions/:executionId/config"),
    Content = new StringContent("{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\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}}/admin/realms/:realm/authentication/executions/:executionId/config");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/config"

	payload := strings.NewReader("{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\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/admin/realms/:realm/authentication/executions/:executionId/config HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 45

{
  "id": "",
  "alias": "",
  "config": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/config")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/config"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\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  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/config")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/config")
  .header("content-type", "application/json")
  .body("{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\n}")
  .asString();

const data = JSON.stringify({
  id: '',
  alias: '',
  config: {}
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/config',
  headers: {'content-type': 'application/json'},
  data: {id: '', alias: '', config: {}}
};

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

const url = '{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/config';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"id":"","alias":"","config":{}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/config',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "id": "",\n  "alias": "",\n  "config": {}\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/admin/realms/: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/admin/realms/: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({id: '', alias: '', config: {}}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/config',
  headers: {'content-type': 'application/json'},
  body: {id: '', alias: '', config: {}},
  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}}/admin/realms/:realm/authentication/executions/:executionId/config');

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

req.type('json');
req.send({
  id: '',
  alias: '',
  config: {}
});

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}}/admin/realms/:realm/authentication/executions/:executionId/config',
  headers: {'content-type': 'application/json'},
  data: {id: '', alias: '', config: {}}
};

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

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

const url = '{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/config';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"id":"","alias":"","config":{}}'
};

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 = @{ @"id": @"",
                              @"alias": @"",
                              @"config": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/realms/: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}}/admin/realms/: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  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\n}" in

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

 "{{baseUrl}}/admin/realms/: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([
    'id' => '',
    'alias' => '',
    'config' => [
        
    ]
  ]),
  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}}/admin/realms/:realm/authentication/executions/:executionId/config', [
  'body' => '{
  "id": "",
  "alias": "",
  "config": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'id' => '',
  'alias' => '',
  'config' => [
    
  ]
]));

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

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

append(json_encode([
  'id' => '',
  'alias' => '',
  'config' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/executions/:executionId/config' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "id": "",
  "alias": "",
  "config": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/config' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "id": "",
  "alias": "",
  "config": {}
}'

import http.client

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

payload = "{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/config"

payload = {
    "id": "",
    "alias": "",
    "config": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/config"

payload <- "{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\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}}/admin/realms/: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  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\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/admin/realms/:realm/authentication/executions/:executionId/config') do |req|
  req.body = "{\n  \"id\": \"\",\n  \"alias\": \"\",\n  \"config\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "id": "",
        "alias": "",
        "config": 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 '{
  "id": "",
  "alias": "",
  "config": {}
}' |  \
  http POST {{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/config \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "id": "",\n  "alias": "",\n  "config": {}\n}' \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/authentication/executions/:executionId/config

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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  \"name\": \"\",\n  \"providerId\": \"\",\n  \"enabled\": false,\n  \"defaultAction\": false,\n  \"priority\": 0,\n  \"config\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias" {:content-type :json
                                                                                                      :form-params {:alias ""
                                                                                                                    :name ""
                                                                                                                    :providerId ""
                                                                                                                    :enabled false
                                                                                                                    :defaultAction false
                                                                                                                    :priority 0
                                                                                                                    :config {}}})

require "http/client"

url = "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"alias\": \"\",\n  \"name\": \"\",\n  \"providerId\": \"\",\n  \"enabled\": false,\n  \"defaultAction\": false,\n  \"priority\": 0,\n  \"config\": {}\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}}/admin/realms/:realm/authentication/required-actions/:alias"),
    Content = new StringContent("{\n  \"alias\": \"\",\n  \"name\": \"\",\n  \"providerId\": \"\",\n  \"enabled\": false,\n  \"defaultAction\": false,\n  \"priority\": 0,\n  \"config\": {}\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}}/admin/realms/:realm/authentication/required-actions/:alias");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"alias\": \"\",\n  \"name\": \"\",\n  \"providerId\": \"\",\n  \"enabled\": false,\n  \"defaultAction\": false,\n  \"priority\": 0,\n  \"config\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias"

	payload := strings.NewReader("{\n  \"alias\": \"\",\n  \"name\": \"\",\n  \"providerId\": \"\",\n  \"enabled\": false,\n  \"defaultAction\": false,\n  \"priority\": 0,\n  \"config\": {}\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/admin/realms/:realm/authentication/required-actions/:alias HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 130

{
  "alias": "",
  "name": "",
  "providerId": "",
  "enabled": false,
  "defaultAction": false,
  "priority": 0,
  "config": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"alias\": \"\",\n  \"name\": \"\",\n  \"providerId\": \"\",\n  \"enabled\": false,\n  \"defaultAction\": false,\n  \"priority\": 0,\n  \"config\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"alias\": \"\",\n  \"name\": \"\",\n  \"providerId\": \"\",\n  \"enabled\": false,\n  \"defaultAction\": false,\n  \"priority\": 0,\n  \"config\": {}\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  \"name\": \"\",\n  \"providerId\": \"\",\n  \"enabled\": false,\n  \"defaultAction\": false,\n  \"priority\": 0,\n  \"config\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias")
  .header("content-type", "application/json")
  .body("{\n  \"alias\": \"\",\n  \"name\": \"\",\n  \"providerId\": \"\",\n  \"enabled\": false,\n  \"defaultAction\": false,\n  \"priority\": 0,\n  \"config\": {}\n}")
  .asString();

const data = JSON.stringify({
  alias: '',
  name: '',
  providerId: '',
  enabled: false,
  defaultAction: false,
  priority: 0,
  config: {}
});

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

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

xhr.open('PUT', '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias',
  headers: {'content-type': 'application/json'},
  data: {
    alias: '',
    name: '',
    providerId: '',
    enabled: false,
    defaultAction: false,
    priority: 0,
    config: {}
  }
};

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

const url = '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"alias":"","name":"","providerId":"","enabled":false,"defaultAction":false,"priority":0,"config":{}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "alias": "",\n  "name": "",\n  "providerId": "",\n  "enabled": false,\n  "defaultAction": false,\n  "priority": 0,\n  "config": {}\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  \"name\": \"\",\n  \"providerId\": \"\",\n  \"enabled\": false,\n  \"defaultAction\": false,\n  \"priority\": 0,\n  \"config\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/admin/realms/: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/admin/realms/: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: '',
  name: '',
  providerId: '',
  enabled: false,
  defaultAction: false,
  priority: 0,
  config: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias',
  headers: {'content-type': 'application/json'},
  body: {
    alias: '',
    name: '',
    providerId: '',
    enabled: false,
    defaultAction: false,
    priority: 0,
    config: {}
  },
  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}}/admin/realms/:realm/authentication/required-actions/:alias');

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

req.type('json');
req.send({
  alias: '',
  name: '',
  providerId: '',
  enabled: false,
  defaultAction: false,
  priority: 0,
  config: {}
});

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}}/admin/realms/:realm/authentication/required-actions/:alias',
  headers: {'content-type': 'application/json'},
  data: {
    alias: '',
    name: '',
    providerId: '',
    enabled: false,
    defaultAction: false,
    priority: 0,
    config: {}
  }
};

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

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

const url = '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"alias":"","name":"","providerId":"","enabled":false,"defaultAction":false,"priority":0,"config":{}}'
};

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": @"",
                              @"name": @"",
                              @"providerId": @"",
                              @"enabled": @NO,
                              @"defaultAction": @NO,
                              @"priority": @0,
                              @"config": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/realms/: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}}/admin/realms/: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  \"name\": \"\",\n  \"providerId\": \"\",\n  \"enabled\": false,\n  \"defaultAction\": false,\n  \"priority\": 0,\n  \"config\": {}\n}" in

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

 "{{baseUrl}}/admin/realms/: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' => '',
    'name' => '',
    'providerId' => '',
    'enabled' => null,
    'defaultAction' => null,
    'priority' => 0,
    'config' => [
        
    ]
  ]),
  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}}/admin/realms/:realm/authentication/required-actions/:alias', [
  'body' => '{
  "alias": "",
  "name": "",
  "providerId": "",
  "enabled": false,
  "defaultAction": false,
  "priority": 0,
  "config": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/: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' => '',
  'name' => '',
  'providerId' => '',
  'enabled' => null,
  'defaultAction' => null,
  'priority' => 0,
  'config' => [
    
  ]
]));

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

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

append(json_encode([
  'alias' => '',
  'name' => '',
  'providerId' => '',
  'enabled' => null,
  'defaultAction' => null,
  'priority' => 0,
  'config' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/authentication/required-actions/:alias' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "alias": "",
  "name": "",
  "providerId": "",
  "enabled": false,
  "defaultAction": false,
  "priority": 0,
  "config": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "alias": "",
  "name": "",
  "providerId": "",
  "enabled": false,
  "defaultAction": false,
  "priority": 0,
  "config": {}
}'

import http.client

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

payload = "{\n  \"alias\": \"\",\n  \"name\": \"\",\n  \"providerId\": \"\",\n  \"enabled\": false,\n  \"defaultAction\": false,\n  \"priority\": 0,\n  \"config\": {}\n}"

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

conn.request("PUT", "/baseUrl/admin/realms/:realm/authentication/required-actions/:alias", payload, headers)

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

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

import requests

url = "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias"

payload = {
    "alias": "",
    "name": "",
    "providerId": "",
    "enabled": False,
    "defaultAction": False,
    "priority": 0,
    "config": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias"

payload <- "{\n  \"alias\": \"\",\n  \"name\": \"\",\n  \"providerId\": \"\",\n  \"enabled\": false,\n  \"defaultAction\": false,\n  \"priority\": 0,\n  \"config\": {}\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}}/admin/realms/: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  \"name\": \"\",\n  \"providerId\": \"\",\n  \"enabled\": false,\n  \"defaultAction\": false,\n  \"priority\": 0,\n  \"config\": {}\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/admin/realms/:realm/authentication/required-actions/:alias') do |req|
  req.body = "{\n  \"alias\": \"\",\n  \"name\": \"\",\n  \"providerId\": \"\",\n  \"enabled\": false,\n  \"defaultAction\": false,\n  \"priority\": 0,\n  \"config\": {}\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}}/admin/realms/:realm/authentication/required-actions/:alias";

    let payload = json!({
        "alias": "",
        "name": "",
        "providerId": "",
        "enabled": false,
        "defaultAction": false,
        "priority": 0,
        "config": json!({})
    });

    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": "",
  "name": "",
  "providerId": "",
  "enabled": false,
  "defaultAction": false,
  "priority": 0,
  "config": {}
}' |  \
  http PUT {{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "alias": "",\n  "name": "",\n  "providerId": "",\n  "enabled": false,\n  "defaultAction": false,\n  "priority": 0,\n  "config": {}\n}' \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/authentication/required-actions/:alias

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "alias": "",
  "name": "",
  "providerId": "",
  "enabled": false,
  "defaultAction": false,
  "priority": 0,
  "config": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate")

require "http/client"

url = "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/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/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate'
};

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

const url = '{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate" in

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

 "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate');

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate")

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

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

import requests

url = "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/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  \"realmCertificate\": false,\n  \"storePassword\": \"\",\n  \"keyPassword\": \"\",\n  \"keyAlias\": \"\",\n  \"realmAlias\": \"\",\n  \"format\": \"\",\n  \"keySize\": 0,\n  \"validity\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate-and-download" {:content-type :json
                                                                                                                              :form-params {:realmCertificate false
                                                                                                                                            :storePassword ""
                                                                                                                                            :keyPassword ""
                                                                                                                                            :keyAlias ""
                                                                                                                                            :realmAlias ""
                                                                                                                                            :format ""
                                                                                                                                            :keySize 0
                                                                                                                                            :validity 0}})

require "http/client"

url = "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate-and-download"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"realmCertificate\": false,\n  \"storePassword\": \"\",\n  \"keyPassword\": \"\",\n  \"keyAlias\": \"\",\n  \"realmAlias\": \"\",\n  \"format\": \"\",\n  \"keySize\": 0,\n  \"validity\": 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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate-and-download"),
    Content = new StringContent("{\n  \"realmCertificate\": false,\n  \"storePassword\": \"\",\n  \"keyPassword\": \"\",\n  \"keyAlias\": \"\",\n  \"realmAlias\": \"\",\n  \"format\": \"\",\n  \"keySize\": 0,\n  \"validity\": 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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate-and-download");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"realmCertificate\": false,\n  \"storePassword\": \"\",\n  \"keyPassword\": \"\",\n  \"keyAlias\": \"\",\n  \"realmAlias\": \"\",\n  \"format\": \"\",\n  \"keySize\": 0,\n  \"validity\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate-and-download"

	payload := strings.NewReader("{\n  \"realmCertificate\": false,\n  \"storePassword\": \"\",\n  \"keyPassword\": \"\",\n  \"keyAlias\": \"\",\n  \"realmAlias\": \"\",\n  \"format\": \"\",\n  \"keySize\": 0,\n  \"validity\": 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/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate-and-download HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 162

{
  "realmCertificate": false,
  "storePassword": "",
  "keyPassword": "",
  "keyAlias": "",
  "realmAlias": "",
  "format": "",
  "keySize": 0,
  "validity": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate-and-download")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"realmCertificate\": false,\n  \"storePassword\": \"\",\n  \"keyPassword\": \"\",\n  \"keyAlias\": \"\",\n  \"realmAlias\": \"\",\n  \"format\": \"\",\n  \"keySize\": 0,\n  \"validity\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate-and-download"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"realmCertificate\": false,\n  \"storePassword\": \"\",\n  \"keyPassword\": \"\",\n  \"keyAlias\": \"\",\n  \"realmAlias\": \"\",\n  \"format\": \"\",\n  \"keySize\": 0,\n  \"validity\": 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  \"realmCertificate\": false,\n  \"storePassword\": \"\",\n  \"keyPassword\": \"\",\n  \"keyAlias\": \"\",\n  \"realmAlias\": \"\",\n  \"format\": \"\",\n  \"keySize\": 0,\n  \"validity\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate-and-download")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate-and-download")
  .header("content-type", "application/json")
  .body("{\n  \"realmCertificate\": false,\n  \"storePassword\": \"\",\n  \"keyPassword\": \"\",\n  \"keyAlias\": \"\",\n  \"realmAlias\": \"\",\n  \"format\": \"\",\n  \"keySize\": 0,\n  \"validity\": 0\n}")
  .asString();

const data = JSON.stringify({
  realmCertificate: false,
  storePassword: '',
  keyPassword: '',
  keyAlias: '',
  realmAlias: '',
  format: '',
  keySize: 0,
  validity: 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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate-and-download');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate-and-download',
  headers: {'content-type': 'application/json'},
  data: {
    realmCertificate: false,
    storePassword: '',
    keyPassword: '',
    keyAlias: '',
    realmAlias: '',
    format: '',
    keySize: 0,
    validity: 0
  }
};

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

const url = '{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate-and-download';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"realmCertificate":false,"storePassword":"","keyPassword":"","keyAlias":"","realmAlias":"","format":"","keySize":0,"validity":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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate-and-download',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "realmCertificate": false,\n  "storePassword": "",\n  "keyPassword": "",\n  "keyAlias": "",\n  "realmAlias": "",\n  "format": "",\n  "keySize": 0,\n  "validity": 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  \"realmCertificate\": false,\n  \"storePassword\": \"\",\n  \"keyPassword\": \"\",\n  \"keyAlias\": \"\",\n  \"realmAlias\": \"\",\n  \"format\": \"\",\n  \"keySize\": 0,\n  \"validity\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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/admin/realms/:realm/clients/:client-uuid/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({
  realmCertificate: false,
  storePassword: '',
  keyPassword: '',
  keyAlias: '',
  realmAlias: '',
  format: '',
  keySize: 0,
  validity: 0
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate-and-download',
  headers: {'content-type': 'application/json'},
  body: {
    realmCertificate: false,
    storePassword: '',
    keyPassword: '',
    keyAlias: '',
    realmAlias: '',
    format: '',
    keySize: 0,
    validity: 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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate-and-download');

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

req.type('json');
req.send({
  realmCertificate: false,
  storePassword: '',
  keyPassword: '',
  keyAlias: '',
  realmAlias: '',
  format: '',
  keySize: 0,
  validity: 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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate-and-download',
  headers: {'content-type': 'application/json'},
  data: {
    realmCertificate: false,
    storePassword: '',
    keyPassword: '',
    keyAlias: '',
    realmAlias: '',
    format: '',
    keySize: 0,
    validity: 0
  }
};

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

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

const url = '{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate-and-download';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"realmCertificate":false,"storePassword":"","keyPassword":"","keyAlias":"","realmAlias":"","format":"","keySize":0,"validity":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 = @{ @"realmCertificate": @NO,
                              @"storePassword": @"",
                              @"keyPassword": @"",
                              @"keyAlias": @"",
                              @"realmAlias": @"",
                              @"format": @"",
                              @"keySize": @0,
                              @"validity": @0 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/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  \"realmCertificate\": false,\n  \"storePassword\": \"\",\n  \"keyPassword\": \"\",\n  \"keyAlias\": \"\",\n  \"realmAlias\": \"\",\n  \"format\": \"\",\n  \"keySize\": 0,\n  \"validity\": 0\n}" in

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

 "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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([
    'realmCertificate' => null,
    'storePassword' => '',
    'keyPassword' => '',
    'keyAlias' => '',
    'realmAlias' => '',
    'format' => '',
    'keySize' => 0,
    'validity' => 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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate-and-download', [
  'body' => '{
  "realmCertificate": false,
  "storePassword": "",
  "keyPassword": "",
  "keyAlias": "",
  "realmAlias": "",
  "format": "",
  "keySize": 0,
  "validity": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate-and-download');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'realmCertificate' => null,
  'storePassword' => '',
  'keyPassword' => '',
  'keyAlias' => '',
  'realmAlias' => '',
  'format' => '',
  'keySize' => 0,
  'validity' => 0
]));

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

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

append(json_encode([
  'realmCertificate' => null,
  'storePassword' => '',
  'keyPassword' => '',
  'keyAlias' => '',
  'realmAlias' => '',
  'format' => '',
  'keySize' => 0,
  'validity' => 0
]));
$request->setRequestUrl('{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate-and-download' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "realmCertificate": false,
  "storePassword": "",
  "keyPassword": "",
  "keyAlias": "",
  "realmAlias": "",
  "format": "",
  "keySize": 0,
  "validity": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate-and-download' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "realmCertificate": false,
  "storePassword": "",
  "keyPassword": "",
  "keyAlias": "",
  "realmAlias": "",
  "format": "",
  "keySize": 0,
  "validity": 0
}'

import http.client

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

payload = "{\n  \"realmCertificate\": false,\n  \"storePassword\": \"\",\n  \"keyPassword\": \"\",\n  \"keyAlias\": \"\",\n  \"realmAlias\": \"\",\n  \"format\": \"\",\n  \"keySize\": 0,\n  \"validity\": 0\n}"

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

conn.request("POST", "/baseUrl/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate-and-download", payload, headers)

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

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

import requests

url = "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate-and-download"

payload = {
    "realmCertificate": False,
    "storePassword": "",
    "keyPassword": "",
    "keyAlias": "",
    "realmAlias": "",
    "format": "",
    "keySize": 0,
    "validity": 0
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate-and-download"

payload <- "{\n  \"realmCertificate\": false,\n  \"storePassword\": \"\",\n  \"keyPassword\": \"\",\n  \"keyAlias\": \"\",\n  \"realmAlias\": \"\",\n  \"format\": \"\",\n  \"keySize\": 0,\n  \"validity\": 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}}/admin/realms/:realm/clients/:client-uuid/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  \"realmCertificate\": false,\n  \"storePassword\": \"\",\n  \"keyPassword\": \"\",\n  \"keyAlias\": \"\",\n  \"realmAlias\": \"\",\n  \"format\": \"\",\n  \"keySize\": 0,\n  \"validity\": 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/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate-and-download') do |req|
  req.body = "{\n  \"realmCertificate\": false,\n  \"storePassword\": \"\",\n  \"keyPassword\": \"\",\n  \"keyAlias\": \"\",\n  \"realmAlias\": \"\",\n  \"format\": \"\",\n  \"keySize\": 0,\n  \"validity\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate-and-download";

    let payload = json!({
        "realmCertificate": false,
        "storePassword": "",
        "keyPassword": "",
        "keyAlias": "",
        "realmAlias": "",
        "format": "",
        "keySize": 0,
        "validity": 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 '{
  "realmCertificate": false,
  "storePassword": "",
  "keyPassword": "",
  "keyAlias": "",
  "realmAlias": "",
  "format": "",
  "keySize": 0,
  "validity": 0
}' |  \
  http POST {{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate-and-download \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "realmCertificate": false,\n  "storePassword": "",\n  "keyPassword": "",\n  "keyAlias": "",\n  "realmAlias": "",\n  "format": "",\n  "keySize": 0,\n  "validity": 0\n}' \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/generate-and-download

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "realmCertificate": false,
  "storePassword": "",
  "keyPassword": "",
  "keyAlias": "",
  "realmAlias": "",
  "format": "",
  "keySize": 0,
  "validity": 0
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/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  \"realmCertificate\": false,\n  \"storePassword\": \"\",\n  \"keyPassword\": \"\",\n  \"keyAlias\": \"\",\n  \"realmAlias\": \"\",\n  \"format\": \"\",\n  \"keySize\": 0,\n  \"validity\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/download" {:content-type :json
                                                                                                                 :form-params {:realmCertificate false
                                                                                                                               :storePassword ""
                                                                                                                               :keyPassword ""
                                                                                                                               :keyAlias ""
                                                                                                                               :realmAlias ""
                                                                                                                               :format ""
                                                                                                                               :keySize 0
                                                                                                                               :validity 0}})

require "http/client"

url = "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/download"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"realmCertificate\": false,\n  \"storePassword\": \"\",\n  \"keyPassword\": \"\",\n  \"keyAlias\": \"\",\n  \"realmAlias\": \"\",\n  \"format\": \"\",\n  \"keySize\": 0,\n  \"validity\": 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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/download"),
    Content = new StringContent("{\n  \"realmCertificate\": false,\n  \"storePassword\": \"\",\n  \"keyPassword\": \"\",\n  \"keyAlias\": \"\",\n  \"realmAlias\": \"\",\n  \"format\": \"\",\n  \"keySize\": 0,\n  \"validity\": 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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/download");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"realmCertificate\": false,\n  \"storePassword\": \"\",\n  \"keyPassword\": \"\",\n  \"keyAlias\": \"\",\n  \"realmAlias\": \"\",\n  \"format\": \"\",\n  \"keySize\": 0,\n  \"validity\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/download"

	payload := strings.NewReader("{\n  \"realmCertificate\": false,\n  \"storePassword\": \"\",\n  \"keyPassword\": \"\",\n  \"keyAlias\": \"\",\n  \"realmAlias\": \"\",\n  \"format\": \"\",\n  \"keySize\": 0,\n  \"validity\": 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/admin/realms/:realm/clients/:client-uuid/certificates/:attr/download HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 162

{
  "realmCertificate": false,
  "storePassword": "",
  "keyPassword": "",
  "keyAlias": "",
  "realmAlias": "",
  "format": "",
  "keySize": 0,
  "validity": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/download")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"realmCertificate\": false,\n  \"storePassword\": \"\",\n  \"keyPassword\": \"\",\n  \"keyAlias\": \"\",\n  \"realmAlias\": \"\",\n  \"format\": \"\",\n  \"keySize\": 0,\n  \"validity\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/download"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"realmCertificate\": false,\n  \"storePassword\": \"\",\n  \"keyPassword\": \"\",\n  \"keyAlias\": \"\",\n  \"realmAlias\": \"\",\n  \"format\": \"\",\n  \"keySize\": 0,\n  \"validity\": 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  \"realmCertificate\": false,\n  \"storePassword\": \"\",\n  \"keyPassword\": \"\",\n  \"keyAlias\": \"\",\n  \"realmAlias\": \"\",\n  \"format\": \"\",\n  \"keySize\": 0,\n  \"validity\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/download")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/download")
  .header("content-type", "application/json")
  .body("{\n  \"realmCertificate\": false,\n  \"storePassword\": \"\",\n  \"keyPassword\": \"\",\n  \"keyAlias\": \"\",\n  \"realmAlias\": \"\",\n  \"format\": \"\",\n  \"keySize\": 0,\n  \"validity\": 0\n}")
  .asString();

const data = JSON.stringify({
  realmCertificate: false,
  storePassword: '',
  keyPassword: '',
  keyAlias: '',
  realmAlias: '',
  format: '',
  keySize: 0,
  validity: 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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/download');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/download',
  headers: {'content-type': 'application/json'},
  data: {
    realmCertificate: false,
    storePassword: '',
    keyPassword: '',
    keyAlias: '',
    realmAlias: '',
    format: '',
    keySize: 0,
    validity: 0
  }
};

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

const url = '{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/download';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"realmCertificate":false,"storePassword":"","keyPassword":"","keyAlias":"","realmAlias":"","format":"","keySize":0,"validity":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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/download',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "realmCertificate": false,\n  "storePassword": "",\n  "keyPassword": "",\n  "keyAlias": "",\n  "realmAlias": "",\n  "format": "",\n  "keySize": 0,\n  "validity": 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  \"realmCertificate\": false,\n  \"storePassword\": \"\",\n  \"keyPassword\": \"\",\n  \"keyAlias\": \"\",\n  \"realmAlias\": \"\",\n  \"format\": \"\",\n  \"keySize\": 0,\n  \"validity\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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/admin/realms/:realm/clients/:client-uuid/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({
  realmCertificate: false,
  storePassword: '',
  keyPassword: '',
  keyAlias: '',
  realmAlias: '',
  format: '',
  keySize: 0,
  validity: 0
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/download',
  headers: {'content-type': 'application/json'},
  body: {
    realmCertificate: false,
    storePassword: '',
    keyPassword: '',
    keyAlias: '',
    realmAlias: '',
    format: '',
    keySize: 0,
    validity: 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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/download');

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

req.type('json');
req.send({
  realmCertificate: false,
  storePassword: '',
  keyPassword: '',
  keyAlias: '',
  realmAlias: '',
  format: '',
  keySize: 0,
  validity: 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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/download',
  headers: {'content-type': 'application/json'},
  data: {
    realmCertificate: false,
    storePassword: '',
    keyPassword: '',
    keyAlias: '',
    realmAlias: '',
    format: '',
    keySize: 0,
    validity: 0
  }
};

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

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

const url = '{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/download';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"realmCertificate":false,"storePassword":"","keyPassword":"","keyAlias":"","realmAlias":"","format":"","keySize":0,"validity":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 = @{ @"realmCertificate": @NO,
                              @"storePassword": @"",
                              @"keyPassword": @"",
                              @"keyAlias": @"",
                              @"realmAlias": @"",
                              @"format": @"",
                              @"keySize": @0,
                              @"validity": @0 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/download" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"realmCertificate\": false,\n  \"storePassword\": \"\",\n  \"keyPassword\": \"\",\n  \"keyAlias\": \"\",\n  \"realmAlias\": \"\",\n  \"format\": \"\",\n  \"keySize\": 0,\n  \"validity\": 0\n}" in

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

 "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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([
    'realmCertificate' => null,
    'storePassword' => '',
    'keyPassword' => '',
    'keyAlias' => '',
    'realmAlias' => '',
    'format' => '',
    'keySize' => 0,
    'validity' => 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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/download', [
  'body' => '{
  "realmCertificate": false,
  "storePassword": "",
  "keyPassword": "",
  "keyAlias": "",
  "realmAlias": "",
  "format": "",
  "keySize": 0,
  "validity": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/download');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'realmCertificate' => null,
  'storePassword' => '',
  'keyPassword' => '',
  'keyAlias' => '',
  'realmAlias' => '',
  'format' => '',
  'keySize' => 0,
  'validity' => 0
]));

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

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

append(json_encode([
  'realmCertificate' => null,
  'storePassword' => '',
  'keyPassword' => '',
  'keyAlias' => '',
  'realmAlias' => '',
  'format' => '',
  'keySize' => 0,
  'validity' => 0
]));
$request->setRequestUrl('{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/download' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "realmCertificate": false,
  "storePassword": "",
  "keyPassword": "",
  "keyAlias": "",
  "realmAlias": "",
  "format": "",
  "keySize": 0,
  "validity": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/download' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "realmCertificate": false,
  "storePassword": "",
  "keyPassword": "",
  "keyAlias": "",
  "realmAlias": "",
  "format": "",
  "keySize": 0,
  "validity": 0
}'

import http.client

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

payload = "{\n  \"realmCertificate\": false,\n  \"storePassword\": \"\",\n  \"keyPassword\": \"\",\n  \"keyAlias\": \"\",\n  \"realmAlias\": \"\",\n  \"format\": \"\",\n  \"keySize\": 0,\n  \"validity\": 0\n}"

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

conn.request("POST", "/baseUrl/admin/realms/:realm/clients/:client-uuid/certificates/:attr/download", payload, headers)

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

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

import requests

url = "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/download"

payload = {
    "realmCertificate": False,
    "storePassword": "",
    "keyPassword": "",
    "keyAlias": "",
    "realmAlias": "",
    "format": "",
    "keySize": 0,
    "validity": 0
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/download"

payload <- "{\n  \"realmCertificate\": false,\n  \"storePassword\": \"\",\n  \"keyPassword\": \"\",\n  \"keyAlias\": \"\",\n  \"realmAlias\": \"\",\n  \"format\": \"\",\n  \"keySize\": 0,\n  \"validity\": 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}}/admin/realms/:realm/clients/:client-uuid/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  \"realmCertificate\": false,\n  \"storePassword\": \"\",\n  \"keyPassword\": \"\",\n  \"keyAlias\": \"\",\n  \"realmAlias\": \"\",\n  \"format\": \"\",\n  \"keySize\": 0,\n  \"validity\": 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/admin/realms/:realm/clients/:client-uuid/certificates/:attr/download') do |req|
  req.body = "{\n  \"realmCertificate\": false,\n  \"storePassword\": \"\",\n  \"keyPassword\": \"\",\n  \"keyAlias\": \"\",\n  \"realmAlias\": \"\",\n  \"format\": \"\",\n  \"keySize\": 0,\n  \"validity\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/download";

    let payload = json!({
        "realmCertificate": false,
        "storePassword": "",
        "keyPassword": "",
        "keyAlias": "",
        "realmAlias": "",
        "format": "",
        "keySize": 0,
        "validity": 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 '{
  "realmCertificate": false,
  "storePassword": "",
  "keyPassword": "",
  "keyAlias": "",
  "realmAlias": "",
  "format": "",
  "keySize": 0,
  "validity": 0
}' |  \
  http POST {{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/download \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "realmCertificate": false,\n  "storePassword": "",\n  "keyPassword": "",\n  "keyAlias": "",\n  "realmAlias": "",\n  "format": "",\n  "keySize": 0,\n  "validity": 0\n}' \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/download

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "realmCertificate": false,
  "storePassword": "",
  "keyPassword": "",
  "keyAlias": "",
  "realmAlias": "",
  "format": "",
  "keySize": 0,
  "validity": 0
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr")

require "http/client"

url = "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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/admin/realms/:realm/clients/:client-uuid/certificates/:attr HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr'
};

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

const url = '{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr" in

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

 "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr');

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/admin/realms/:realm/clients/:client-uuid/certificates/:attr")

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

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

import requests

url = "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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/admin/realms/:realm/clients/:client-uuid/certificates/:attr') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload")

require "http/client"

url = "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/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/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload'
};

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

const url = '{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload" in

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

 "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload');

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload")

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

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

import requests

url = "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload-certificate");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload-certificate")

require "http/client"

url = "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/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/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload-certificate HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload-certificate")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload-certificate")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload-certificate');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload-certificate'
};

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

const url = '{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload-certificate',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload-certificate" in

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

 "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload-certificate');

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload-certificate');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload-certificate');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload-certificate' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload-certificate' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload-certificate")

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

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

import requests

url = "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload-certificate"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload-certificate"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload-certificate') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload-certificate

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/clients/:client-uuid/certificates/:attr/upload-certificate

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/:realm/clients/:client-uuid/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}}/admin/realms/: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  \"expiration\": 0,\n  \"count\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/admin/realms/:realm/clients-initial-access" {:content-type :json
                                                                                       :form-params {:expiration 0
                                                                                                     :count 0}})

require "http/client"

url = "{{baseUrl}}/admin/realms/:realm/clients-initial-access"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"expiration\": 0,\n  \"count\": 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}}/admin/realms/:realm/clients-initial-access"),
    Content = new StringContent("{\n  \"expiration\": 0,\n  \"count\": 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}}/admin/realms/:realm/clients-initial-access");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"expiration\": 0,\n  \"count\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin/realms/:realm/clients-initial-access"

	payload := strings.NewReader("{\n  \"expiration\": 0,\n  \"count\": 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/admin/realms/:realm/clients-initial-access HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 35

{
  "expiration": 0,
  "count": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin/realms/:realm/clients-initial-access")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"expiration\": 0,\n  \"count\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/:realm/clients-initial-access"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"expiration\": 0,\n  \"count\": 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  \"expiration\": 0,\n  \"count\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin/realms/:realm/clients-initial-access")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin/realms/:realm/clients-initial-access")
  .header("content-type", "application/json")
  .body("{\n  \"expiration\": 0,\n  \"count\": 0\n}")
  .asString();

const data = JSON.stringify({
  expiration: 0,
  count: 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}}/admin/realms/:realm/clients-initial-access');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/realms/:realm/clients-initial-access',
  headers: {'content-type': 'application/json'},
  data: {expiration: 0, count: 0}
};

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

const url = '{{baseUrl}}/admin/realms/:realm/clients-initial-access';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"expiration":0,"count":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}}/admin/realms/:realm/clients-initial-access',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "expiration": 0,\n  "count": 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  \"expiration\": 0,\n  \"count\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/admin/realms/: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/admin/realms/: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({expiration: 0, count: 0}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/realms/:realm/clients-initial-access',
  headers: {'content-type': 'application/json'},
  body: {expiration: 0, count: 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}}/admin/realms/:realm/clients-initial-access');

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

req.type('json');
req.send({
  expiration: 0,
  count: 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}}/admin/realms/:realm/clients-initial-access',
  headers: {'content-type': 'application/json'},
  data: {expiration: 0, count: 0}
};

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

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

const url = '{{baseUrl}}/admin/realms/:realm/clients-initial-access';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"expiration":0,"count":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 = @{ @"expiration": @0,
                              @"count": @0 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/clients-initial-access" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"expiration\": 0,\n  \"count\": 0\n}" in

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

 "{{baseUrl}}/admin/realms/: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([
    'expiration' => 0,
    'count' => 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}}/admin/realms/:realm/clients-initial-access', [
  'body' => '{
  "expiration": 0,
  "count": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/:realm/clients-initial-access');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'expiration' => 0,
  'count' => 0
]));

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

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

append(json_encode([
  'expiration' => 0,
  'count' => 0
]));
$request->setRequestUrl('{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/clients-initial-access' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "expiration": 0,
  "count": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/clients-initial-access' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "expiration": 0,
  "count": 0
}'

import http.client

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

payload = "{\n  \"expiration\": 0,\n  \"count\": 0\n}"

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

conn.request("POST", "/baseUrl/admin/realms/:realm/clients-initial-access", payload, headers)

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

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

import requests

url = "{{baseUrl}}/admin/realms/:realm/clients-initial-access"

payload = {
    "expiration": 0,
    "count": 0
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/:realm/clients-initial-access"

payload <- "{\n  \"expiration\": 0,\n  \"count\": 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}}/admin/realms/: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  \"expiration\": 0,\n  \"count\": 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/admin/realms/:realm/clients-initial-access') do |req|
  req.body = "{\n  \"expiration\": 0,\n  \"count\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/realms/:realm/clients-initial-access";

    let payload = json!({
        "expiration": 0,
        "count": 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 '{
  "expiration": 0,
  "count": 0
}' |  \
  http POST {{baseUrl}}/admin/realms/:realm/clients-initial-access \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "expiration": 0,\n  "count": 0\n}' \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/clients-initial-access

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/clients-initial-access/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/admin/realms/:realm/clients-initial-access/:id")

require "http/client"

url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/:realm/clients-initial-access/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/admin/realms/:realm/clients-initial-access/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/clients-initial-access/:id")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/clients-initial-access/:id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/admin/realms/:realm/clients-initial-access/:id'
};

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

const url = '{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/clients-initial-access/:id" in

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

 "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/clients-initial-access/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/:realm/clients-initial-access/:id');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/admin/realms/:realm/clients-initial-access/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/realms/:realm/clients-initial-access/:id' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/clients-initial-access/:id' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/admin/realms/:realm/clients-initial-access/:id")

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

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

import requests

url = "{{baseUrl}}/admin/realms/:realm/clients-initial-access/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/clients-initial-access/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/clients-initial-access/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/clients-initial-access");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/admin/realms/:realm/clients-initial-access")

require "http/client"

url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/:realm/clients-initial-access HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin/realms/:realm/clients-initial-access")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/clients-initial-access")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/clients-initial-access');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/realms/:realm/clients-initial-access'
};

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

const url = '{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/clients-initial-access',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/clients-initial-access" in

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

 "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/clients-initial-access');

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/:realm/clients-initial-access');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/admin/realms/:realm/clients-initial-access');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/realms/:realm/clients-initial-access' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/clients-initial-access' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/admin/realms/:realm/clients-initial-access")

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

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

import requests

url = "{{baseUrl}}/admin/realms/:realm/clients-initial-access"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/:realm/clients-initial-access"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/realms/: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/admin/realms/:realm/clients-initial-access') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/clients-initial-access

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/clients-initial-access

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/client-registration-policy/providers");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/admin/realms/:realm/client-registration-policy/providers")

require "http/client"

url = "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/:realm/client-registration-policy/providers HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin/realms/:realm/client-registration-policy/providers")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/client-registration-policy/providers")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/client-registration-policy/providers');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/realms/:realm/client-registration-policy/providers'
};

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

const url = '{{baseUrl}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/client-registration-policy/providers" in

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

 "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/client-registration-policy/providers');

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/:realm/client-registration-policy/providers');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/admin/realms/:realm/client-registration-policy/providers');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/realms/:realm/client-registration-policy/providers' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/client-registration-policy/providers' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/admin/realms/:realm/client-registration-policy/providers")

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

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

import requests

url = "{{baseUrl}}/admin/realms/:realm/client-registration-policy/providers"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/: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}}/admin/realms/: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/admin/realms/: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}}/admin/realms/: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}}/admin/realms/:realm/client-registration-policy/providers

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/client-registration-policy/providers

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/: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}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-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  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\n  }\n]");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id" {:content-type :json
                                                                                                                :form-params [{:id ""
                                                                                                                               :name ""
                                                                                                                               :description ""
                                                                                                                               :scopeParamRequired false
                                                                                                                               :composite false
                                                                                                                               :composites {:realm []
                                                                                                                                            :client {}
                                                                                                                                            :application {}}
                                                                                                                               :clientRole false
                                                                                                                               :containerId ""
                                                                                                                               :attributes {}}]})

require "http/client"

url = "{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\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}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id"),
    Content = new StringContent("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\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}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\n  }\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id"

	payload := strings.NewReader("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\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/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 280

[
  {
    "id": "",
    "name": "",
    "description": "",
    "scopeParamRequired": false,
    "composite": false,
    "composites": {
      "realm": [],
      "client": {},
      "application": {}
    },
    "clientRole": false,
    "containerId": "",
    "attributes": {}
  }
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\n  }\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\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    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\n  }\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id")
  .header("content-type", "application/json")
  .body("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\n  }\n]")
  .asString();

const data = JSON.stringify([
  {
    id: '',
    name: '',
    description: '',
    scopeParamRequired: false,
    composite: false,
    composites: {
      realm: [],
      client: {},
      application: {}
    },
    clientRole: false,
    containerId: '',
    attributes: {}
  }
]);

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id',
  headers: {'content-type': 'application/json'},
  data: [
    {
      id: '',
      name: '',
      description: '',
      scopeParamRequired: false,
      composite: false,
      composites: {realm: [], client: {}, application: {}},
      clientRole: false,
      containerId: '',
      attributes: {}
    }
  ]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '[{"id":"","name":"","description":"","scopeParamRequired":false,"composite":false,"composites":{"realm":[],"client":{},"application":{}},"clientRole":false,"containerId":"","attributes":{}}]'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  {\n    "id": "",\n    "name": "",\n    "description": "",\n    "scopeParamRequired": false,\n    "composite": false,\n    "composites": {\n      "realm": [],\n      "client": {},\n      "application": {}\n    },\n    "clientRole": false,\n    "containerId": "",\n    "attributes": {}\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    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\n  }\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id")
  .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/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-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([
  {
    id: '',
    name: '',
    description: '',
    scopeParamRequired: false,
    composite: false,
    composites: {realm: [], client: {}, application: {}},
    clientRole: false,
    containerId: '',
    attributes: {}
  }
]));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id',
  headers: {'content-type': 'application/json'},
  body: [
    {
      id: '',
      name: '',
      description: '',
      scopeParamRequired: false,
      composite: false,
      composites: {realm: [], client: {}, application: {}},
      clientRole: false,
      containerId: '',
      attributes: {}
    }
  ],
  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}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send([
  {
    id: '',
    name: '',
    description: '',
    scopeParamRequired: false,
    composite: false,
    composites: {
      realm: [],
      client: {},
      application: {}
    },
    clientRole: false,
    containerId: '',
    attributes: {}
  }
]);

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}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id',
  headers: {'content-type': 'application/json'},
  data: [
    {
      id: '',
      name: '',
      description: '',
      scopeParamRequired: false,
      composite: false,
      composites: {realm: [], client: {}, application: {}},
      clientRole: false,
      containerId: '',
      attributes: {}
    }
  ]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '[{"id":"","name":"","description":"","scopeParamRequired":false,"composite":false,"composites":{"realm":[],"client":{},"application":{}},"clientRole":false,"containerId":"","attributes":{}}]'
};

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 = @[ @{ @"id": @"", @"name": @"", @"description": @"", @"scopeParamRequired": @NO, @"composite": @NO, @"composites": @{ @"realm": @[  ], @"client": @{  }, @"application": @{  } }, @"clientRole": @NO, @"containerId": @"", @"attributes": @{  } } ];

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\n  }\n]" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id",
  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([
    [
        'id' => '',
        'name' => '',
        'description' => '',
        'scopeParamRequired' => null,
        'composite' => null,
        'composites' => [
                'realm' => [
                                
                ],
                'client' => [
                                
                ],
                'application' => [
                                
                ]
        ],
        'clientRole' => null,
        'containerId' => '',
        'attributes' => [
                
        ]
    ]
  ]),
  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}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id', [
  'body' => '[
  {
    "id": "",
    "name": "",
    "description": "",
    "scopeParamRequired": false,
    "composite": false,
    "composites": {
      "realm": [],
      "client": {},
      "application": {}
    },
    "clientRole": false,
    "containerId": "",
    "attributes": {}
  }
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    'id' => '',
    'name' => '',
    'description' => '',
    'scopeParamRequired' => null,
    'composite' => null,
    'composites' => [
        'realm' => [
                
        ],
        'client' => [
                
        ],
        'application' => [
                
        ]
    ],
    'clientRole' => null,
    'containerId' => '',
    'attributes' => [
        
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  [
    'id' => '',
    'name' => '',
    'description' => '',
    'scopeParamRequired' => null,
    'composite' => null,
    'composites' => [
        'realm' => [
                
        ],
        'client' => [
                
        ],
        'application' => [
                
        ]
    ],
    'clientRole' => null,
    'containerId' => '',
    'attributes' => [
        
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id');
$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}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  {
    "id": "",
    "name": "",
    "description": "",
    "scopeParamRequired": false,
    "composite": false,
    "composites": {
      "realm": [],
      "client": {},
      "application": {}
    },
    "clientRole": false,
    "containerId": "",
    "attributes": {}
  }
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  {
    "id": "",
    "name": "",
    "description": "",
    "scopeParamRequired": false,
    "composite": false,
    "composites": {
      "realm": [],
      "client": {},
      "application": {}
    },
    "clientRole": false,
    "containerId": "",
    "attributes": {}
  }
]'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\n  }\n]"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id"

payload = [
    {
        "id": "",
        "name": "",
        "description": "",
        "scopeParamRequired": False,
        "composite": False,
        "composites": {
            "realm": [],
            "client": {},
            "application": {}
        },
        "clientRole": False,
        "containerId": "",
        "attributes": {}
    }
]
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id"

payload <- "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\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}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id")

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    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\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/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id') do |req|
  req.body = "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\n  }\n]"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id";

    let payload = (
        json!({
            "id": "",
            "name": "",
            "description": "",
            "scopeParamRequired": false,
            "composite": false,
            "composites": json!({
                "realm": (),
                "client": json!({}),
                "application": json!({})
            }),
            "clientRole": false,
            "containerId": "",
            "attributes": 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 '[
  {
    "id": "",
    "name": "",
    "description": "",
    "scopeParamRequired": false,
    "composite": false,
    "composites": {
      "realm": [],
      "client": {},
      "application": {}
    },
    "clientRole": false,
    "containerId": "",
    "attributes": {}
  }
]' |  \
  http POST {{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '[\n  {\n    "id": "",\n    "name": "",\n    "description": "",\n    "scopeParamRequired": false,\n    "composite": false,\n    "composites": {\n      "realm": [],\n      "client": {},\n      "application": {}\n    },\n    "clientRole": false,\n    "containerId": "",\n    "attributes": {}\n  }\n]' \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  [
    "id": "",
    "name": "",
    "description": "",
    "scopeParamRequired": false,
    "composite": false,
    "composites": [
      "realm": [],
      "client": [],
      "application": []
    ],
    "clientRole": false,
    "containerId": "",
    "attributes": []
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-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  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\n  }\n]");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id" {:content-type :json
                                                                                                                  :form-params [{:id ""
                                                                                                                                 :name ""
                                                                                                                                 :description ""
                                                                                                                                 :scopeParamRequired false
                                                                                                                                 :composite false
                                                                                                                                 :composites {:realm []
                                                                                                                                              :client {}
                                                                                                                                              :application {}}
                                                                                                                                 :clientRole false
                                                                                                                                 :containerId ""
                                                                                                                                 :attributes {}}]})

require "http/client"

url = "{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\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}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id"),
    Content = new StringContent("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\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}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\n  }\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id"

	payload := strings.NewReader("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\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/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 280

[
  {
    "id": "",
    "name": "",
    "description": "",
    "scopeParamRequired": false,
    "composite": false,
    "composites": {
      "realm": [],
      "client": {},
      "application": {}
    },
    "clientRole": false,
    "containerId": "",
    "attributes": {}
  }
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\n  }\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\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    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\n  }\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id")
  .header("content-type", "application/json")
  .body("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\n  }\n]")
  .asString();

const data = JSON.stringify([
  {
    id: '',
    name: '',
    description: '',
    scopeParamRequired: false,
    composite: false,
    composites: {
      realm: [],
      client: {},
      application: {}
    },
    clientRole: false,
    containerId: '',
    attributes: {}
  }
]);

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id',
  headers: {'content-type': 'application/json'},
  data: [
    {
      id: '',
      name: '',
      description: '',
      scopeParamRequired: false,
      composite: false,
      composites: {realm: [], client: {}, application: {}},
      clientRole: false,
      containerId: '',
      attributes: {}
    }
  ]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '[{"id":"","name":"","description":"","scopeParamRequired":false,"composite":false,"composites":{"realm":[],"client":{},"application":{}},"clientRole":false,"containerId":"","attributes":{}}]'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  {\n    "id": "",\n    "name": "",\n    "description": "",\n    "scopeParamRequired": false,\n    "composite": false,\n    "composites": {\n      "realm": [],\n      "client": {},\n      "application": {}\n    },\n    "clientRole": false,\n    "containerId": "",\n    "attributes": {}\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    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\n  }\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id")
  .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/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-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([
  {
    id: '',
    name: '',
    description: '',
    scopeParamRequired: false,
    composite: false,
    composites: {realm: [], client: {}, application: {}},
    clientRole: false,
    containerId: '',
    attributes: {}
  }
]));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id',
  headers: {'content-type': 'application/json'},
  body: [
    {
      id: '',
      name: '',
      description: '',
      scopeParamRequired: false,
      composite: false,
      composites: {realm: [], client: {}, application: {}},
      clientRole: false,
      containerId: '',
      attributes: {}
    }
  ],
  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}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send([
  {
    id: '',
    name: '',
    description: '',
    scopeParamRequired: false,
    composite: false,
    composites: {
      realm: [],
      client: {},
      application: {}
    },
    clientRole: false,
    containerId: '',
    attributes: {}
  }
]);

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}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id',
  headers: {'content-type': 'application/json'},
  data: [
    {
      id: '',
      name: '',
      description: '',
      scopeParamRequired: false,
      composite: false,
      composites: {realm: [], client: {}, application: {}},
      clientRole: false,
      containerId: '',
      attributes: {}
    }
  ]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '[{"id":"","name":"","description":"","scopeParamRequired":false,"composite":false,"composites":{"realm":[],"client":{},"application":{}},"clientRole":false,"containerId":"","attributes":{}}]'
};

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 = @[ @{ @"id": @"", @"name": @"", @"description": @"", @"scopeParamRequired": @NO, @"composite": @NO, @"composites": @{ @"realm": @[  ], @"client": @{  }, @"application": @{  } }, @"clientRole": @NO, @"containerId": @"", @"attributes": @{  } } ];

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\n  }\n]" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id",
  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([
    [
        'id' => '',
        'name' => '',
        'description' => '',
        'scopeParamRequired' => null,
        'composite' => null,
        'composites' => [
                'realm' => [
                                
                ],
                'client' => [
                                
                ],
                'application' => [
                                
                ]
        ],
        'clientRole' => null,
        'containerId' => '',
        'attributes' => [
                
        ]
    ]
  ]),
  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}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id', [
  'body' => '[
  {
    "id": "",
    "name": "",
    "description": "",
    "scopeParamRequired": false,
    "composite": false,
    "composites": {
      "realm": [],
      "client": {},
      "application": {}
    },
    "clientRole": false,
    "containerId": "",
    "attributes": {}
  }
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    'id' => '',
    'name' => '',
    'description' => '',
    'scopeParamRequired' => null,
    'composite' => null,
    'composites' => [
        'realm' => [
                
        ],
        'client' => [
                
        ],
        'application' => [
                
        ]
    ],
    'clientRole' => null,
    'containerId' => '',
    'attributes' => [
        
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  [
    'id' => '',
    'name' => '',
    'description' => '',
    'scopeParamRequired' => null,
    'composite' => null,
    'composites' => [
        'realm' => [
                
        ],
        'client' => [
                
        ],
        'application' => [
                
        ]
    ],
    'clientRole' => null,
    'containerId' => '',
    'attributes' => [
        
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id');
$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}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  {
    "id": "",
    "name": "",
    "description": "",
    "scopeParamRequired": false,
    "composite": false,
    "composites": {
      "realm": [],
      "client": {},
      "application": {}
    },
    "clientRole": false,
    "containerId": "",
    "attributes": {}
  }
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  {
    "id": "",
    "name": "",
    "description": "",
    "scopeParamRequired": false,
    "composite": false,
    "composites": {
      "realm": [],
      "client": {},
      "application": {}
    },
    "clientRole": false,
    "containerId": "",
    "attributes": {}
  }
]'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\n  }\n]"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id"

payload = [
    {
        "id": "",
        "name": "",
        "description": "",
        "scopeParamRequired": False,
        "composite": False,
        "composites": {
            "realm": [],
            "client": {},
            "application": {}
        },
        "clientRole": False,
        "containerId": "",
        "attributes": {}
    }
]
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id"

payload <- "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\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}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id")

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    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\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/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id') do |req|
  req.body = "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\n  }\n]"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id";

    let payload = (
        json!({
            "id": "",
            "name": "",
            "description": "",
            "scopeParamRequired": false,
            "composite": false,
            "composites": json!({
                "realm": (),
                "client": json!({}),
                "application": json!({})
            }),
            "clientRole": false,
            "containerId": "",
            "attributes": 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 '[
  {
    "id": "",
    "name": "",
    "description": "",
    "scopeParamRequired": false,
    "composite": false,
    "composites": {
      "realm": [],
      "client": {},
      "application": {}
    },
    "clientRole": false,
    "containerId": "",
    "attributes": {}
  }
]' |  \
  http POST {{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '[\n  {\n    "id": "",\n    "name": "",\n    "description": "",\n    "scopeParamRequired": false,\n    "composite": false,\n    "composites": {\n      "realm": [],\n      "client": {},\n      "application": {}\n    },\n    "clientRole": false,\n    "containerId": "",\n    "attributes": {}\n  }\n]' \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  [
    "id": "",
    "name": "",
    "description": "",
    "scopeParamRequired": false,
    "composite": false,
    "composites": [
      "realm": [],
      "client": [],
      "application": []
    ],
    "clientRole": false,
    "containerId": "",
    "attributes": []
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id")! 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}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-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  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\n  }\n]");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id" {:content-type :json
                                                                                                                  :form-params [{:id ""
                                                                                                                                 :name ""
                                                                                                                                 :description ""
                                                                                                                                 :scopeParamRequired false
                                                                                                                                 :composite false
                                                                                                                                 :composites {:realm []
                                                                                                                                              :client {}
                                                                                                                                              :application {}}
                                                                                                                                 :clientRole false
                                                                                                                                 :containerId ""
                                                                                                                                 :attributes {}}]})

require "http/client"

url = "{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\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}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id"),
    Content = new StringContent("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\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}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id");
var request = new RestRequest("", Method.Delete);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\n  }\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id"

	payload := strings.NewReader("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\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/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 280

[
  {
    "id": "",
    "name": "",
    "description": "",
    "scopeParamRequired": false,
    "composite": false,
    "composites": {
      "realm": [],
      "client": {},
      "application": {}
    },
    "clientRole": false,
    "containerId": "",
    "attributes": {}
  }
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\n  }\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id"))
    .header("content-type", "application/json")
    .method("DELETE", HttpRequest.BodyPublishers.ofString("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\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    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\n  }\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id")
  .delete(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id")
  .header("content-type", "application/json")
  .body("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\n  }\n]")
  .asString();

const data = JSON.stringify([
  {
    id: '',
    name: '',
    description: '',
    scopeParamRequired: false,
    composite: false,
    composites: {
      realm: [],
      client: {},
      application: {}
    },
    clientRole: false,
    containerId: '',
    attributes: {}
  }
]);

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id',
  headers: {'content-type': 'application/json'},
  data: [
    {
      id: '',
      name: '',
      description: '',
      scopeParamRequired: false,
      composite: false,
      composites: {realm: [], client: {}, application: {}},
      clientRole: false,
      containerId: '',
      attributes: {}
    }
  ]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id';
const options = {
  method: 'DELETE',
  headers: {'content-type': 'application/json'},
  body: '[{"id":"","name":"","description":"","scopeParamRequired":false,"composite":false,"composites":{"realm":[],"client":{},"application":{}},"clientRole":false,"containerId":"","attributes":{}}]'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id',
  method: 'DELETE',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  {\n    "id": "",\n    "name": "",\n    "description": "",\n    "scopeParamRequired": false,\n    "composite": false,\n    "composites": {\n      "realm": [],\n      "client": {},\n      "application": {}\n    },\n    "clientRole": false,\n    "containerId": "",\n    "attributes": {}\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    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\n  }\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id")
  .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/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-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([
  {
    id: '',
    name: '',
    description: '',
    scopeParamRequired: false,
    composite: false,
    composites: {realm: [], client: {}, application: {}},
    clientRole: false,
    containerId: '',
    attributes: {}
  }
]));
req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id',
  headers: {'content-type': 'application/json'},
  body: [
    {
      id: '',
      name: '',
      description: '',
      scopeParamRequired: false,
      composite: false,
      composites: {realm: [], client: {}, application: {}},
      clientRole: false,
      containerId: '',
      attributes: {}
    }
  ],
  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}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send([
  {
    id: '',
    name: '',
    description: '',
    scopeParamRequired: false,
    composite: false,
    composites: {
      realm: [],
      client: {},
      application: {}
    },
    clientRole: false,
    containerId: '',
    attributes: {}
  }
]);

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}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id',
  headers: {'content-type': 'application/json'},
  data: [
    {
      id: '',
      name: '',
      description: '',
      scopeParamRequired: false,
      composite: false,
      composites: {realm: [], client: {}, application: {}},
      clientRole: false,
      containerId: '',
      attributes: {}
    }
  ]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id';
const options = {
  method: 'DELETE',
  headers: {'content-type': 'application/json'},
  body: '[{"id":"","name":"","description":"","scopeParamRequired":false,"composite":false,"composites":{"realm":[],"client":{},"application":{}},"clientRole":false,"containerId":"","attributes":{}}]'
};

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 = @[ @{ @"id": @"", @"name": @"", @"description": @"", @"scopeParamRequired": @NO, @"composite": @NO, @"composites": @{ @"realm": @[  ], @"client": @{  }, @"application": @{  } }, @"clientRole": @NO, @"containerId": @"", @"attributes": @{  } } ];

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id"]
                                                       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}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\n  }\n]" in

Client.call ~headers ~body `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id",
  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([
    [
        'id' => '',
        'name' => '',
        'description' => '',
        'scopeParamRequired' => null,
        'composite' => null,
        'composites' => [
                'realm' => [
                                
                ],
                'client' => [
                                
                ],
                'application' => [
                                
                ]
        ],
        'clientRole' => null,
        'containerId' => '',
        'attributes' => [
                
        ]
    ]
  ]),
  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}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id', [
  'body' => '[
  {
    "id": "",
    "name": "",
    "description": "",
    "scopeParamRequired": false,
    "composite": false,
    "composites": {
      "realm": [],
      "client": {},
      "application": {}
    },
    "clientRole": false,
    "containerId": "",
    "attributes": {}
  }
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    'id' => '',
    'name' => '',
    'description' => '',
    'scopeParamRequired' => null,
    'composite' => null,
    'composites' => [
        'realm' => [
                
        ],
        'client' => [
                
        ],
        'application' => [
                
        ]
    ],
    'clientRole' => null,
    'containerId' => '',
    'attributes' => [
        
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  [
    'id' => '',
    'name' => '',
    'description' => '',
    'scopeParamRequired' => null,
    'composite' => null,
    'composites' => [
        'realm' => [
                
        ],
        'client' => [
                
        ],
        'application' => [
                
        ]
    ],
    'clientRole' => null,
    'containerId' => '',
    'attributes' => [
        
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id');
$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}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id' -Method DELETE -Headers $headers -ContentType 'application/json' -Body '[
  {
    "id": "",
    "name": "",
    "description": "",
    "scopeParamRequired": false,
    "composite": false,
    "composites": {
      "realm": [],
      "client": {},
      "application": {}
    },
    "clientRole": false,
    "containerId": "",
    "attributes": {}
  }
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id' -Method DELETE -Headers $headers -ContentType 'application/json' -Body '[
  {
    "id": "",
    "name": "",
    "description": "",
    "scopeParamRequired": false,
    "composite": false,
    "composites": {
      "realm": [],
      "client": {},
      "application": {}
    },
    "clientRole": false,
    "containerId": "",
    "attributes": {}
  }
]'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\n  }\n]"

headers = { 'content-type': "application/json" }

conn.request("DELETE", "/baseUrl/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id"

payload = [
    {
        "id": "",
        "name": "",
        "description": "",
        "scopeParamRequired": False,
        "composite": False,
        "composites": {
            "realm": [],
            "client": {},
            "application": {}
        },
        "clientRole": False,
        "containerId": "",
        "attributes": {}
    }
]
headers = {"content-type": "application/json"}

response = requests.delete(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id"

payload <- "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\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}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id")

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    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\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/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id') do |req|
  req.body = "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\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}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id";

    let payload = (
        json!({
            "id": "",
            "name": "",
            "description": "",
            "scopeParamRequired": false,
            "composite": false,
            "composites": json!({
                "realm": (),
                "client": json!({}),
                "application": json!({})
            }),
            "clientRole": false,
            "containerId": "",
            "attributes": json!({})
        })
    );

    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 '[
  {
    "id": "",
    "name": "",
    "description": "",
    "scopeParamRequired": false,
    "composite": false,
    "composites": {
      "realm": [],
      "client": {},
      "application": {}
    },
    "clientRole": false,
    "containerId": "",
    "attributes": {}
  }
]' |  \
  http DELETE {{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id \
  content-type:application/json

wget --quiet \
  --method DELETE \
  --header 'content-type: application/json' \
  --body-data '[\n  {\n    "id": "",\n    "name": "",\n    "description": "",\n    "scopeParamRequired": false,\n    "composite": false,\n    "composites": {\n      "realm": [],\n      "client": {},\n      "application": {}\n    },\n    "clientRole": false,\n    "containerId": "",\n    "attributes": {}\n  }\n]' \
  --output-document \
  - {{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  [
    "id": "",
    "name": "",
    "description": "",
    "scopeParamRequired": false,
    "composite": false,
    "composites": [
      "realm": [],
      "client": [],
      "application": []
    ],
    "clientRole": false,
    "containerId": "",
    "attributes": []
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/realms/:realm/users/:user-id/role-mappings/clients/:client-id")! 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}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-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  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\n  }\n]");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id" {:content-type :json
                                                                                                                    :form-params [{:id ""
                                                                                                                                   :name ""
                                                                                                                                   :description ""
                                                                                                                                   :scopeParamRequired false
                                                                                                                                   :composite false
                                                                                                                                   :composites {:realm []
                                                                                                                                                :client {}
                                                                                                                                                :application {}}
                                                                                                                                   :clientRole false
                                                                                                                                   :containerId ""
                                                                                                                                   :attributes {}}]})

require "http/client"

url = "{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\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}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id"),
    Content = new StringContent("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\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}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id");
var request = new RestRequest("", Method.Delete);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\n  }\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id"

	payload := strings.NewReader("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\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/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 280

[
  {
    "id": "",
    "name": "",
    "description": "",
    "scopeParamRequired": false,
    "composite": false,
    "composites": {
      "realm": [],
      "client": {},
      "application": {}
    },
    "clientRole": false,
    "containerId": "",
    "attributes": {}
  }
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\n  }\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id"))
    .header("content-type", "application/json")
    .method("DELETE", HttpRequest.BodyPublishers.ofString("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\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    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\n  }\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id")
  .delete(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id")
  .header("content-type", "application/json")
  .body("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\n  }\n]")
  .asString();

const data = JSON.stringify([
  {
    id: '',
    name: '',
    description: '',
    scopeParamRequired: false,
    composite: false,
    composites: {
      realm: [],
      client: {},
      application: {}
    },
    clientRole: false,
    containerId: '',
    attributes: {}
  }
]);

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id',
  headers: {'content-type': 'application/json'},
  data: [
    {
      id: '',
      name: '',
      description: '',
      scopeParamRequired: false,
      composite: false,
      composites: {realm: [], client: {}, application: {}},
      clientRole: false,
      containerId: '',
      attributes: {}
    }
  ]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id';
const options = {
  method: 'DELETE',
  headers: {'content-type': 'application/json'},
  body: '[{"id":"","name":"","description":"","scopeParamRequired":false,"composite":false,"composites":{"realm":[],"client":{},"application":{}},"clientRole":false,"containerId":"","attributes":{}}]'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id',
  method: 'DELETE',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  {\n    "id": "",\n    "name": "",\n    "description": "",\n    "scopeParamRequired": false,\n    "composite": false,\n    "composites": {\n      "realm": [],\n      "client": {},\n      "application": {}\n    },\n    "clientRole": false,\n    "containerId": "",\n    "attributes": {}\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    \"id\": \"\",\n    \"name\": \"\",\n    \"description\": \"\",\n    \"scopeParamRequired\": false,\n    \"composite\": false,\n    \"composites\": {\n      \"realm\": [],\n      \"client\": {},\n      \"application\": {}\n    },\n    \"clientRole\": false,\n    \"containerId\": \"\",\n    \"attributes\": {}\n  }\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/admin/realms/:realm/groups/:group-id/role-mappings/clients/:client-id")
  .delete(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()