CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1alpha1/:name:attachTrust");

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  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1alpha1/:name:attachTrust" {:content-type :json
                                                                       :form-params {:trust {:createTime ""
                                                                                             :lastKnownTrustConnectedHeartbeatTime ""
                                                                                             :selectiveAuthentication false
                                                                                             :state ""
                                                                                             :stateDescription ""
                                                                                             :targetDnsIpAddresses []
                                                                                             :targetDomainName ""
                                                                                             :trustDirection ""
                                                                                             :trustHandshakeSecret ""
                                                                                             :trustType ""
                                                                                             :updateTime ""}}})

require "http/client"

url = "{{baseUrl}}/v1alpha1/:name:attachTrust"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\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}}/v1alpha1/:name:attachTrust"),
    Content = new StringContent("{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\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}}/v1alpha1/:name:attachTrust");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/:name:attachTrust"

	payload := strings.NewReader("{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\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/v1alpha1/:name:attachTrust HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 333

{
  "trust": {
    "createTime": "",
    "lastKnownTrustConnectedHeartbeatTime": "",
    "selectiveAuthentication": false,
    "state": "",
    "stateDescription": "",
    "targetDnsIpAddresses": [],
    "targetDomainName": "",
    "trustDirection": "",
    "trustHandshakeSecret": "",
    "trustType": "",
    "updateTime": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1alpha1/:name:attachTrust")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/:name:attachTrust"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\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  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:name:attachTrust")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1alpha1/:name:attachTrust")
  .header("content-type", "application/json")
  .body("{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  trust: {
    createTime: '',
    lastKnownTrustConnectedHeartbeatTime: '',
    selectiveAuthentication: false,
    state: '',
    stateDescription: '',
    targetDnsIpAddresses: [],
    targetDomainName: '',
    trustDirection: '',
    trustHandshakeSecret: '',
    trustType: '',
    updateTime: ''
  }
});

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

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

xhr.open('POST', '{{baseUrl}}/v1alpha1/:name:attachTrust');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:name:attachTrust',
  headers: {'content-type': 'application/json'},
  data: {
    trust: {
      createTime: '',
      lastKnownTrustConnectedHeartbeatTime: '',
      selectiveAuthentication: false,
      state: '',
      stateDescription: '',
      targetDnsIpAddresses: [],
      targetDomainName: '',
      trustDirection: '',
      trustHandshakeSecret: '',
      trustType: '',
      updateTime: ''
    }
  }
};

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

const url = '{{baseUrl}}/v1alpha1/:name:attachTrust';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"trust":{"createTime":"","lastKnownTrustConnectedHeartbeatTime":"","selectiveAuthentication":false,"state":"","stateDescription":"","targetDnsIpAddresses":[],"targetDomainName":"","trustDirection":"","trustHandshakeSecret":"","trustType":"","updateTime":""}}'
};

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}}/v1alpha1/:name:attachTrust',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "trust": {\n    "createTime": "",\n    "lastKnownTrustConnectedHeartbeatTime": "",\n    "selectiveAuthentication": false,\n    "state": "",\n    "stateDescription": "",\n    "targetDnsIpAddresses": [],\n    "targetDomainName": "",\n    "trustDirection": "",\n    "trustHandshakeSecret": "",\n    "trustType": "",\n    "updateTime": ""\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  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:name:attachTrust")
  .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/v1alpha1/:name:attachTrust',
  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({
  trust: {
    createTime: '',
    lastKnownTrustConnectedHeartbeatTime: '',
    selectiveAuthentication: false,
    state: '',
    stateDescription: '',
    targetDnsIpAddresses: [],
    targetDomainName: '',
    trustDirection: '',
    trustHandshakeSecret: '',
    trustType: '',
    updateTime: ''
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:name:attachTrust',
  headers: {'content-type': 'application/json'},
  body: {
    trust: {
      createTime: '',
      lastKnownTrustConnectedHeartbeatTime: '',
      selectiveAuthentication: false,
      state: '',
      stateDescription: '',
      targetDnsIpAddresses: [],
      targetDomainName: '',
      trustDirection: '',
      trustHandshakeSecret: '',
      trustType: '',
      updateTime: ''
    }
  },
  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}}/v1alpha1/:name:attachTrust');

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

req.type('json');
req.send({
  trust: {
    createTime: '',
    lastKnownTrustConnectedHeartbeatTime: '',
    selectiveAuthentication: false,
    state: '',
    stateDescription: '',
    targetDnsIpAddresses: [],
    targetDomainName: '',
    trustDirection: '',
    trustHandshakeSecret: '',
    trustType: '',
    updateTime: ''
  }
});

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}}/v1alpha1/:name:attachTrust',
  headers: {'content-type': 'application/json'},
  data: {
    trust: {
      createTime: '',
      lastKnownTrustConnectedHeartbeatTime: '',
      selectiveAuthentication: false,
      state: '',
      stateDescription: '',
      targetDnsIpAddresses: [],
      targetDomainName: '',
      trustDirection: '',
      trustHandshakeSecret: '',
      trustType: '',
      updateTime: ''
    }
  }
};

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

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

const url = '{{baseUrl}}/v1alpha1/:name:attachTrust';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"trust":{"createTime":"","lastKnownTrustConnectedHeartbeatTime":"","selectiveAuthentication":false,"state":"","stateDescription":"","targetDnsIpAddresses":[],"targetDomainName":"","trustDirection":"","trustHandshakeSecret":"","trustType":"","updateTime":""}}'
};

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 = @{ @"trust": @{ @"createTime": @"", @"lastKnownTrustConnectedHeartbeatTime": @"", @"selectiveAuthentication": @NO, @"state": @"", @"stateDescription": @"", @"targetDnsIpAddresses": @[  ], @"targetDomainName": @"", @"trustDirection": @"", @"trustHandshakeSecret": @"", @"trustType": @"", @"updateTime": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1alpha1/:name:attachTrust"]
                                                       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}}/v1alpha1/:name:attachTrust" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/v1alpha1/:name:attachTrust",
  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([
    'trust' => [
        'createTime' => '',
        'lastKnownTrustConnectedHeartbeatTime' => '',
        'selectiveAuthentication' => null,
        'state' => '',
        'stateDescription' => '',
        'targetDnsIpAddresses' => [
                
        ],
        'targetDomainName' => '',
        'trustDirection' => '',
        'trustHandshakeSecret' => '',
        'trustType' => '',
        'updateTime' => ''
    ]
  ]),
  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}}/v1alpha1/:name:attachTrust', [
  'body' => '{
  "trust": {
    "createTime": "",
    "lastKnownTrustConnectedHeartbeatTime": "",
    "selectiveAuthentication": false,
    "state": "",
    "stateDescription": "",
    "targetDnsIpAddresses": [],
    "targetDomainName": "",
    "trustDirection": "",
    "trustHandshakeSecret": "",
    "trustType": "",
    "updateTime": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:name:attachTrust');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'trust' => [
    'createTime' => '',
    'lastKnownTrustConnectedHeartbeatTime' => '',
    'selectiveAuthentication' => null,
    'state' => '',
    'stateDescription' => '',
    'targetDnsIpAddresses' => [
        
    ],
    'targetDomainName' => '',
    'trustDirection' => '',
    'trustHandshakeSecret' => '',
    'trustType' => '',
    'updateTime' => ''
  ]
]));

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

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

append(json_encode([
  'trust' => [
    'createTime' => '',
    'lastKnownTrustConnectedHeartbeatTime' => '',
    'selectiveAuthentication' => null,
    'state' => '',
    'stateDescription' => '',
    'targetDnsIpAddresses' => [
        
    ],
    'targetDomainName' => '',
    'trustDirection' => '',
    'trustHandshakeSecret' => '',
    'trustType' => '',
    'updateTime' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1alpha1/:name:attachTrust');
$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}}/v1alpha1/:name:attachTrust' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "trust": {
    "createTime": "",
    "lastKnownTrustConnectedHeartbeatTime": "",
    "selectiveAuthentication": false,
    "state": "",
    "stateDescription": "",
    "targetDnsIpAddresses": [],
    "targetDomainName": "",
    "trustDirection": "",
    "trustHandshakeSecret": "",
    "trustType": "",
    "updateTime": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:name:attachTrust' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "trust": {
    "createTime": "",
    "lastKnownTrustConnectedHeartbeatTime": "",
    "selectiveAuthentication": false,
    "state": "",
    "stateDescription": "",
    "targetDnsIpAddresses": [],
    "targetDomainName": "",
    "trustDirection": "",
    "trustHandshakeSecret": "",
    "trustType": "",
    "updateTime": ""
  }
}'

import http.client

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

payload = "{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\n  }\n}"

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

conn.request("POST", "/baseUrl/v1alpha1/:name:attachTrust", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:name:attachTrust"

payload = { "trust": {
        "createTime": "",
        "lastKnownTrustConnectedHeartbeatTime": "",
        "selectiveAuthentication": False,
        "state": "",
        "stateDescription": "",
        "targetDnsIpAddresses": [],
        "targetDomainName": "",
        "trustDirection": "",
        "trustHandshakeSecret": "",
        "trustType": "",
        "updateTime": ""
    } }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:name:attachTrust"

payload <- "{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\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}}/v1alpha1/:name:attachTrust")

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  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\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/v1alpha1/:name:attachTrust') do |req|
  req.body = "{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1alpha1/:name:attachTrust";

    let payload = json!({"trust": json!({
            "createTime": "",
            "lastKnownTrustConnectedHeartbeatTime": "",
            "selectiveAuthentication": false,
            "state": "",
            "stateDescription": "",
            "targetDnsIpAddresses": (),
            "targetDomainName": "",
            "trustDirection": "",
            "trustHandshakeSecret": "",
            "trustType": "",
            "updateTime": ""
        })});

    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 '{
  "trust": {
    "createTime": "",
    "lastKnownTrustConnectedHeartbeatTime": "",
    "selectiveAuthentication": false,
    "state": "",
    "stateDescription": "",
    "targetDnsIpAddresses": [],
    "targetDomainName": "",
    "trustDirection": "",
    "trustHandshakeSecret": "",
    "trustType": "",
    "updateTime": ""
  }
}' |  \
  http POST {{baseUrl}}/v1alpha1/:name:attachTrust \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "trust": {\n    "createTime": "",\n    "lastKnownTrustConnectedHeartbeatTime": "",\n    "selectiveAuthentication": false,\n    "state": "",\n    "stateDescription": "",\n    "targetDnsIpAddresses": [],\n    "targetDomainName": "",\n    "trustDirection": "",\n    "trustHandshakeSecret": "",\n    "trustType": "",\n    "updateTime": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/v1alpha1/:name:attachTrust

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["trust": [
    "createTime": "",
    "lastKnownTrustConnectedHeartbeatTime": "",
    "selectiveAuthentication": false,
    "state": "",
    "stateDescription": "",
    "targetDnsIpAddresses": [],
    "targetDomainName": "",
    "trustDirection": "",
    "trustHandshakeSecret": "",
    "trustType": "",
    "updateTime": ""
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1alpha1/:name:attachTrust")! 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}}/v1alpha1/:parent/backups");

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  \"createTime\": \"\",\n  \"description\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"type\": \"\",\n  \"updateTime\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1alpha1/:parent/backups" {:content-type :json
                                                                     :form-params {:createTime ""
                                                                                   :description ""
                                                                                   :labels {}
                                                                                   :name ""
                                                                                   :state ""
                                                                                   :statusMessage ""
                                                                                   :type ""
                                                                                   :updateTime ""}})

require "http/client"

url = "{{baseUrl}}/v1alpha1/:parent/backups"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"createTime\": \"\",\n  \"description\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"type\": \"\",\n  \"updateTime\": \"\"\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}}/v1alpha1/:parent/backups"),
    Content = new StringContent("{\n  \"createTime\": \"\",\n  \"description\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"type\": \"\",\n  \"updateTime\": \"\"\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}}/v1alpha1/:parent/backups");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"createTime\": \"\",\n  \"description\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"type\": \"\",\n  \"updateTime\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/:parent/backups"

	payload := strings.NewReader("{\n  \"createTime\": \"\",\n  \"description\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"type\": \"\",\n  \"updateTime\": \"\"\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/v1alpha1/:parent/backups HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 145

{
  "createTime": "",
  "description": "",
  "labels": {},
  "name": "",
  "state": "",
  "statusMessage": "",
  "type": "",
  "updateTime": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1alpha1/:parent/backups")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"createTime\": \"\",\n  \"description\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"type\": \"\",\n  \"updateTime\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/:parent/backups"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"createTime\": \"\",\n  \"description\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"type\": \"\",\n  \"updateTime\": \"\"\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  \"createTime\": \"\",\n  \"description\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"type\": \"\",\n  \"updateTime\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:parent/backups")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1alpha1/:parent/backups")
  .header("content-type", "application/json")
  .body("{\n  \"createTime\": \"\",\n  \"description\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"type\": \"\",\n  \"updateTime\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  createTime: '',
  description: '',
  labels: {},
  name: '',
  state: '',
  statusMessage: '',
  type: '',
  updateTime: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/v1alpha1/:parent/backups');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:parent/backups',
  headers: {'content-type': 'application/json'},
  data: {
    createTime: '',
    description: '',
    labels: {},
    name: '',
    state: '',
    statusMessage: '',
    type: '',
    updateTime: ''
  }
};

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

const url = '{{baseUrl}}/v1alpha1/:parent/backups';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"createTime":"","description":"","labels":{},"name":"","state":"","statusMessage":"","type":"","updateTime":""}'
};

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}}/v1alpha1/:parent/backups',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "createTime": "",\n  "description": "",\n  "labels": {},\n  "name": "",\n  "state": "",\n  "statusMessage": "",\n  "type": "",\n  "updateTime": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"createTime\": \"\",\n  \"description\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"type\": \"\",\n  \"updateTime\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:parent/backups")
  .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/v1alpha1/:parent/backups',
  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({
  createTime: '',
  description: '',
  labels: {},
  name: '',
  state: '',
  statusMessage: '',
  type: '',
  updateTime: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:parent/backups',
  headers: {'content-type': 'application/json'},
  body: {
    createTime: '',
    description: '',
    labels: {},
    name: '',
    state: '',
    statusMessage: '',
    type: '',
    updateTime: ''
  },
  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}}/v1alpha1/:parent/backups');

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

req.type('json');
req.send({
  createTime: '',
  description: '',
  labels: {},
  name: '',
  state: '',
  statusMessage: '',
  type: '',
  updateTime: ''
});

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}}/v1alpha1/:parent/backups',
  headers: {'content-type': 'application/json'},
  data: {
    createTime: '',
    description: '',
    labels: {},
    name: '',
    state: '',
    statusMessage: '',
    type: '',
    updateTime: ''
  }
};

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

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

const url = '{{baseUrl}}/v1alpha1/:parent/backups';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"createTime":"","description":"","labels":{},"name":"","state":"","statusMessage":"","type":"","updateTime":""}'
};

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 = @{ @"createTime": @"",
                              @"description": @"",
                              @"labels": @{  },
                              @"name": @"",
                              @"state": @"",
                              @"statusMessage": @"",
                              @"type": @"",
                              @"updateTime": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1alpha1/:parent/backups"]
                                                       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}}/v1alpha1/:parent/backups" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"createTime\": \"\",\n  \"description\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"type\": \"\",\n  \"updateTime\": \"\"\n}" in

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

 "{{baseUrl}}/v1alpha1/:parent/backups",
  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([
    'createTime' => '',
    'description' => '',
    'labels' => [
        
    ],
    'name' => '',
    'state' => '',
    'statusMessage' => '',
    'type' => '',
    'updateTime' => ''
  ]),
  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}}/v1alpha1/:parent/backups', [
  'body' => '{
  "createTime": "",
  "description": "",
  "labels": {},
  "name": "",
  "state": "",
  "statusMessage": "",
  "type": "",
  "updateTime": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:parent/backups');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'createTime' => '',
  'description' => '',
  'labels' => [
    
  ],
  'name' => '',
  'state' => '',
  'statusMessage' => '',
  'type' => '',
  'updateTime' => ''
]));

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

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

append(json_encode([
  'createTime' => '',
  'description' => '',
  'labels' => [
    
  ],
  'name' => '',
  'state' => '',
  'statusMessage' => '',
  'type' => '',
  'updateTime' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1alpha1/:parent/backups');
$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}}/v1alpha1/:parent/backups' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "createTime": "",
  "description": "",
  "labels": {},
  "name": "",
  "state": "",
  "statusMessage": "",
  "type": "",
  "updateTime": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:parent/backups' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "createTime": "",
  "description": "",
  "labels": {},
  "name": "",
  "state": "",
  "statusMessage": "",
  "type": "",
  "updateTime": ""
}'

import http.client

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

payload = "{\n  \"createTime\": \"\",\n  \"description\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"type\": \"\",\n  \"updateTime\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v1alpha1/:parent/backups", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:parent/backups"

payload = {
    "createTime": "",
    "description": "",
    "labels": {},
    "name": "",
    "state": "",
    "statusMessage": "",
    "type": "",
    "updateTime": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:parent/backups"

payload <- "{\n  \"createTime\": \"\",\n  \"description\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"type\": \"\",\n  \"updateTime\": \"\"\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}}/v1alpha1/:parent/backups")

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  \"createTime\": \"\",\n  \"description\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"type\": \"\",\n  \"updateTime\": \"\"\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/v1alpha1/:parent/backups') do |req|
  req.body = "{\n  \"createTime\": \"\",\n  \"description\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"type\": \"\",\n  \"updateTime\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1alpha1/:parent/backups";

    let payload = json!({
        "createTime": "",
        "description": "",
        "labels": json!({}),
        "name": "",
        "state": "",
        "statusMessage": "",
        "type": "",
        "updateTime": ""
    });

    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 '{
  "createTime": "",
  "description": "",
  "labels": {},
  "name": "",
  "state": "",
  "statusMessage": "",
  "type": "",
  "updateTime": ""
}' |  \
  http POST {{baseUrl}}/v1alpha1/:parent/backups \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "createTime": "",\n  "description": "",\n  "labels": {},\n  "name": "",\n  "state": "",\n  "statusMessage": "",\n  "type": "",\n  "updateTime": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1alpha1/:parent/backups

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "createTime": "",
  "description": "",
  "labels": [],
  "name": "",
  "state": "",
  "statusMessage": "",
  "type": "",
  "updateTime": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1alpha1/:parent/backups")! 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}}/v1alpha1/:parent/backups");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1alpha1/:parent/backups")

require "http/client"

url = "{{baseUrl}}/v1alpha1/:parent/backups"

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}}/v1alpha1/:parent/backups"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1alpha1/:parent/backups");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/:parent/backups"

	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/v1alpha1/:parent/backups HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1alpha1/:parent/backups")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/:parent/backups"))
    .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}}/v1alpha1/:parent/backups")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1alpha1/:parent/backups")
  .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}}/v1alpha1/:parent/backups');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1alpha1/:parent/backups'};

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

const url = '{{baseUrl}}/v1alpha1/:parent/backups';
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}}/v1alpha1/:parent/backups',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:parent/backups")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1alpha1/:parent/backups',
  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}}/v1alpha1/:parent/backups'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1alpha1/:parent/backups');

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}}/v1alpha1/:parent/backups'};

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

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

const url = '{{baseUrl}}/v1alpha1/:parent/backups';
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}}/v1alpha1/:parent/backups"]
                                                       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}}/v1alpha1/:parent/backups" in

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

 "{{baseUrl}}/v1alpha1/:parent/backups",
  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}}/v1alpha1/:parent/backups');

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:parent/backups');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1alpha1/:parent/backups');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1alpha1/:parent/backups' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:parent/backups' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1alpha1/:parent/backups")

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:parent/backups"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:parent/backups"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1alpha1/:parent/backups")

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/v1alpha1/:parent/backups') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1alpha1/:parent/backups";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v1alpha1/:parent/backups

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1alpha1/:parent/backups

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1alpha1/:parent/backups")! 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}}/v1alpha1/:domain:checkMigrationPermission");

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}}/v1alpha1/:domain:checkMigrationPermission" {:content-type :json})

require "http/client"

url = "{{baseUrl}}/v1alpha1/:domain:checkMigrationPermission"
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}}/v1alpha1/:domain:checkMigrationPermission"),
    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}}/v1alpha1/:domain:checkMigrationPermission");
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}}/v1alpha1/:domain:checkMigrationPermission"

	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/v1alpha1/:domain:checkMigrationPermission HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 2

{}

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/:domain:checkMigrationPermission"))
    .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}}/v1alpha1/:domain:checkMigrationPermission")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1alpha1/:domain:checkMigrationPermission")
  .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}}/v1alpha1/:domain:checkMigrationPermission');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:domain:checkMigrationPermission',
  headers: {'content-type': 'application/json'},
  data: {}
};

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

const url = '{{baseUrl}}/v1alpha1/:domain:checkMigrationPermission';
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}}/v1alpha1/:domain:checkMigrationPermission',
  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}}/v1alpha1/:domain:checkMigrationPermission")
  .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/v1alpha1/:domain:checkMigrationPermission',
  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}}/v1alpha1/:domain:checkMigrationPermission',
  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}}/v1alpha1/:domain:checkMigrationPermission');

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}}/v1alpha1/:domain:checkMigrationPermission',
  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}}/v1alpha1/:domain:checkMigrationPermission';
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}}/v1alpha1/:domain:checkMigrationPermission"]
                                                       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}}/v1alpha1/:domain:checkMigrationPermission" 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}}/v1alpha1/:domain:checkMigrationPermission",
  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}}/v1alpha1/:domain:checkMigrationPermission', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:domain:checkMigrationPermission');
$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}}/v1alpha1/:domain:checkMigrationPermission');
$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}}/v1alpha1/:domain:checkMigrationPermission' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:domain:checkMigrationPermission' -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/v1alpha1/:domain:checkMigrationPermission", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:domain:checkMigrationPermission"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:domain:checkMigrationPermission"

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}}/v1alpha1/:domain:checkMigrationPermission")

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/v1alpha1/:domain:checkMigrationPermission') 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}}/v1alpha1/:domain:checkMigrationPermission";

    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}}/v1alpha1/:domain:checkMigrationPermission \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - {{baseUrl}}/v1alpha1/:domain:checkMigrationPermission

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}}/v1alpha1/:domain:checkMigrationPermission")! 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}}/v1alpha1/:parent/domains");

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  \"auditLogsEnabled\": false,\n  \"authorizedNetworks\": [],\n  \"createTime\": \"\",\n  \"fqdn\": \"\",\n  \"labels\": {},\n  \"locations\": [],\n  \"managedIdentitiesAdminName\": \"\",\n  \"name\": \"\",\n  \"reservedIpRange\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"trusts\": [\n    {\n      \"createTime\": \"\",\n      \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n      \"selectiveAuthentication\": false,\n      \"state\": \"\",\n      \"stateDescription\": \"\",\n      \"targetDnsIpAddresses\": [],\n      \"targetDomainName\": \"\",\n      \"trustDirection\": \"\",\n      \"trustHandshakeSecret\": \"\",\n      \"trustType\": \"\",\n      \"updateTime\": \"\"\n    }\n  ],\n  \"updateTime\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1alpha1/:parent/domains" {:content-type :json
                                                                     :form-params {:auditLogsEnabled false
                                                                                   :authorizedNetworks []
                                                                                   :createTime ""
                                                                                   :fqdn ""
                                                                                   :labels {}
                                                                                   :locations []
                                                                                   :managedIdentitiesAdminName ""
                                                                                   :name ""
                                                                                   :reservedIpRange ""
                                                                                   :state ""
                                                                                   :statusMessage ""
                                                                                   :trusts [{:createTime ""
                                                                                             :lastKnownTrustConnectedHeartbeatTime ""
                                                                                             :selectiveAuthentication false
                                                                                             :state ""
                                                                                             :stateDescription ""
                                                                                             :targetDnsIpAddresses []
                                                                                             :targetDomainName ""
                                                                                             :trustDirection ""
                                                                                             :trustHandshakeSecret ""
                                                                                             :trustType ""
                                                                                             :updateTime ""}]
                                                                                   :updateTime ""}})

require "http/client"

url = "{{baseUrl}}/v1alpha1/:parent/domains"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"auditLogsEnabled\": false,\n  \"authorizedNetworks\": [],\n  \"createTime\": \"\",\n  \"fqdn\": \"\",\n  \"labels\": {},\n  \"locations\": [],\n  \"managedIdentitiesAdminName\": \"\",\n  \"name\": \"\",\n  \"reservedIpRange\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"trusts\": [\n    {\n      \"createTime\": \"\",\n      \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n      \"selectiveAuthentication\": false,\n      \"state\": \"\",\n      \"stateDescription\": \"\",\n      \"targetDnsIpAddresses\": [],\n      \"targetDomainName\": \"\",\n      \"trustDirection\": \"\",\n      \"trustHandshakeSecret\": \"\",\n      \"trustType\": \"\",\n      \"updateTime\": \"\"\n    }\n  ],\n  \"updateTime\": \"\"\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}}/v1alpha1/:parent/domains"),
    Content = new StringContent("{\n  \"auditLogsEnabled\": false,\n  \"authorizedNetworks\": [],\n  \"createTime\": \"\",\n  \"fqdn\": \"\",\n  \"labels\": {},\n  \"locations\": [],\n  \"managedIdentitiesAdminName\": \"\",\n  \"name\": \"\",\n  \"reservedIpRange\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"trusts\": [\n    {\n      \"createTime\": \"\",\n      \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n      \"selectiveAuthentication\": false,\n      \"state\": \"\",\n      \"stateDescription\": \"\",\n      \"targetDnsIpAddresses\": [],\n      \"targetDomainName\": \"\",\n      \"trustDirection\": \"\",\n      \"trustHandshakeSecret\": \"\",\n      \"trustType\": \"\",\n      \"updateTime\": \"\"\n    }\n  ],\n  \"updateTime\": \"\"\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}}/v1alpha1/:parent/domains");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"auditLogsEnabled\": false,\n  \"authorizedNetworks\": [],\n  \"createTime\": \"\",\n  \"fqdn\": \"\",\n  \"labels\": {},\n  \"locations\": [],\n  \"managedIdentitiesAdminName\": \"\",\n  \"name\": \"\",\n  \"reservedIpRange\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"trusts\": [\n    {\n      \"createTime\": \"\",\n      \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n      \"selectiveAuthentication\": false,\n      \"state\": \"\",\n      \"stateDescription\": \"\",\n      \"targetDnsIpAddresses\": [],\n      \"targetDomainName\": \"\",\n      \"trustDirection\": \"\",\n      \"trustHandshakeSecret\": \"\",\n      \"trustType\": \"\",\n      \"updateTime\": \"\"\n    }\n  ],\n  \"updateTime\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/:parent/domains"

	payload := strings.NewReader("{\n  \"auditLogsEnabled\": false,\n  \"authorizedNetworks\": [],\n  \"createTime\": \"\",\n  \"fqdn\": \"\",\n  \"labels\": {},\n  \"locations\": [],\n  \"managedIdentitiesAdminName\": \"\",\n  \"name\": \"\",\n  \"reservedIpRange\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"trusts\": [\n    {\n      \"createTime\": \"\",\n      \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n      \"selectiveAuthentication\": false,\n      \"state\": \"\",\n      \"stateDescription\": \"\",\n      \"targetDnsIpAddresses\": [],\n      \"targetDomainName\": \"\",\n      \"trustDirection\": \"\",\n      \"trustHandshakeSecret\": \"\",\n      \"trustType\": \"\",\n      \"updateTime\": \"\"\n    }\n  ],\n  \"updateTime\": \"\"\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/v1alpha1/:parent/domains HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 627

{
  "auditLogsEnabled": false,
  "authorizedNetworks": [],
  "createTime": "",
  "fqdn": "",
  "labels": {},
  "locations": [],
  "managedIdentitiesAdminName": "",
  "name": "",
  "reservedIpRange": "",
  "state": "",
  "statusMessage": "",
  "trusts": [
    {
      "createTime": "",
      "lastKnownTrustConnectedHeartbeatTime": "",
      "selectiveAuthentication": false,
      "state": "",
      "stateDescription": "",
      "targetDnsIpAddresses": [],
      "targetDomainName": "",
      "trustDirection": "",
      "trustHandshakeSecret": "",
      "trustType": "",
      "updateTime": ""
    }
  ],
  "updateTime": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1alpha1/:parent/domains")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"auditLogsEnabled\": false,\n  \"authorizedNetworks\": [],\n  \"createTime\": \"\",\n  \"fqdn\": \"\",\n  \"labels\": {},\n  \"locations\": [],\n  \"managedIdentitiesAdminName\": \"\",\n  \"name\": \"\",\n  \"reservedIpRange\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"trusts\": [\n    {\n      \"createTime\": \"\",\n      \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n      \"selectiveAuthentication\": false,\n      \"state\": \"\",\n      \"stateDescription\": \"\",\n      \"targetDnsIpAddresses\": [],\n      \"targetDomainName\": \"\",\n      \"trustDirection\": \"\",\n      \"trustHandshakeSecret\": \"\",\n      \"trustType\": \"\",\n      \"updateTime\": \"\"\n    }\n  ],\n  \"updateTime\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/:parent/domains"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"auditLogsEnabled\": false,\n  \"authorizedNetworks\": [],\n  \"createTime\": \"\",\n  \"fqdn\": \"\",\n  \"labels\": {},\n  \"locations\": [],\n  \"managedIdentitiesAdminName\": \"\",\n  \"name\": \"\",\n  \"reservedIpRange\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"trusts\": [\n    {\n      \"createTime\": \"\",\n      \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n      \"selectiveAuthentication\": false,\n      \"state\": \"\",\n      \"stateDescription\": \"\",\n      \"targetDnsIpAddresses\": [],\n      \"targetDomainName\": \"\",\n      \"trustDirection\": \"\",\n      \"trustHandshakeSecret\": \"\",\n      \"trustType\": \"\",\n      \"updateTime\": \"\"\n    }\n  ],\n  \"updateTime\": \"\"\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  \"auditLogsEnabled\": false,\n  \"authorizedNetworks\": [],\n  \"createTime\": \"\",\n  \"fqdn\": \"\",\n  \"labels\": {},\n  \"locations\": [],\n  \"managedIdentitiesAdminName\": \"\",\n  \"name\": \"\",\n  \"reservedIpRange\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"trusts\": [\n    {\n      \"createTime\": \"\",\n      \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n      \"selectiveAuthentication\": false,\n      \"state\": \"\",\n      \"stateDescription\": \"\",\n      \"targetDnsIpAddresses\": [],\n      \"targetDomainName\": \"\",\n      \"trustDirection\": \"\",\n      \"trustHandshakeSecret\": \"\",\n      \"trustType\": \"\",\n      \"updateTime\": \"\"\n    }\n  ],\n  \"updateTime\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:parent/domains")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1alpha1/:parent/domains")
  .header("content-type", "application/json")
  .body("{\n  \"auditLogsEnabled\": false,\n  \"authorizedNetworks\": [],\n  \"createTime\": \"\",\n  \"fqdn\": \"\",\n  \"labels\": {},\n  \"locations\": [],\n  \"managedIdentitiesAdminName\": \"\",\n  \"name\": \"\",\n  \"reservedIpRange\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"trusts\": [\n    {\n      \"createTime\": \"\",\n      \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n      \"selectiveAuthentication\": false,\n      \"state\": \"\",\n      \"stateDescription\": \"\",\n      \"targetDnsIpAddresses\": [],\n      \"targetDomainName\": \"\",\n      \"trustDirection\": \"\",\n      \"trustHandshakeSecret\": \"\",\n      \"trustType\": \"\",\n      \"updateTime\": \"\"\n    }\n  ],\n  \"updateTime\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  auditLogsEnabled: false,
  authorizedNetworks: [],
  createTime: '',
  fqdn: '',
  labels: {},
  locations: [],
  managedIdentitiesAdminName: '',
  name: '',
  reservedIpRange: '',
  state: '',
  statusMessage: '',
  trusts: [
    {
      createTime: '',
      lastKnownTrustConnectedHeartbeatTime: '',
      selectiveAuthentication: false,
      state: '',
      stateDescription: '',
      targetDnsIpAddresses: [],
      targetDomainName: '',
      trustDirection: '',
      trustHandshakeSecret: '',
      trustType: '',
      updateTime: ''
    }
  ],
  updateTime: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/v1alpha1/:parent/domains');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:parent/domains',
  headers: {'content-type': 'application/json'},
  data: {
    auditLogsEnabled: false,
    authorizedNetworks: [],
    createTime: '',
    fqdn: '',
    labels: {},
    locations: [],
    managedIdentitiesAdminName: '',
    name: '',
    reservedIpRange: '',
    state: '',
    statusMessage: '',
    trusts: [
      {
        createTime: '',
        lastKnownTrustConnectedHeartbeatTime: '',
        selectiveAuthentication: false,
        state: '',
        stateDescription: '',
        targetDnsIpAddresses: [],
        targetDomainName: '',
        trustDirection: '',
        trustHandshakeSecret: '',
        trustType: '',
        updateTime: ''
      }
    ],
    updateTime: ''
  }
};

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

const url = '{{baseUrl}}/v1alpha1/:parent/domains';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"auditLogsEnabled":false,"authorizedNetworks":[],"createTime":"","fqdn":"","labels":{},"locations":[],"managedIdentitiesAdminName":"","name":"","reservedIpRange":"","state":"","statusMessage":"","trusts":[{"createTime":"","lastKnownTrustConnectedHeartbeatTime":"","selectiveAuthentication":false,"state":"","stateDescription":"","targetDnsIpAddresses":[],"targetDomainName":"","trustDirection":"","trustHandshakeSecret":"","trustType":"","updateTime":""}],"updateTime":""}'
};

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}}/v1alpha1/:parent/domains',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "auditLogsEnabled": false,\n  "authorizedNetworks": [],\n  "createTime": "",\n  "fqdn": "",\n  "labels": {},\n  "locations": [],\n  "managedIdentitiesAdminName": "",\n  "name": "",\n  "reservedIpRange": "",\n  "state": "",\n  "statusMessage": "",\n  "trusts": [\n    {\n      "createTime": "",\n      "lastKnownTrustConnectedHeartbeatTime": "",\n      "selectiveAuthentication": false,\n      "state": "",\n      "stateDescription": "",\n      "targetDnsIpAddresses": [],\n      "targetDomainName": "",\n      "trustDirection": "",\n      "trustHandshakeSecret": "",\n      "trustType": "",\n      "updateTime": ""\n    }\n  ],\n  "updateTime": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"auditLogsEnabled\": false,\n  \"authorizedNetworks\": [],\n  \"createTime\": \"\",\n  \"fqdn\": \"\",\n  \"labels\": {},\n  \"locations\": [],\n  \"managedIdentitiesAdminName\": \"\",\n  \"name\": \"\",\n  \"reservedIpRange\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"trusts\": [\n    {\n      \"createTime\": \"\",\n      \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n      \"selectiveAuthentication\": false,\n      \"state\": \"\",\n      \"stateDescription\": \"\",\n      \"targetDnsIpAddresses\": [],\n      \"targetDomainName\": \"\",\n      \"trustDirection\": \"\",\n      \"trustHandshakeSecret\": \"\",\n      \"trustType\": \"\",\n      \"updateTime\": \"\"\n    }\n  ],\n  \"updateTime\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:parent/domains")
  .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/v1alpha1/:parent/domains',
  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({
  auditLogsEnabled: false,
  authorizedNetworks: [],
  createTime: '',
  fqdn: '',
  labels: {},
  locations: [],
  managedIdentitiesAdminName: '',
  name: '',
  reservedIpRange: '',
  state: '',
  statusMessage: '',
  trusts: [
    {
      createTime: '',
      lastKnownTrustConnectedHeartbeatTime: '',
      selectiveAuthentication: false,
      state: '',
      stateDescription: '',
      targetDnsIpAddresses: [],
      targetDomainName: '',
      trustDirection: '',
      trustHandshakeSecret: '',
      trustType: '',
      updateTime: ''
    }
  ],
  updateTime: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:parent/domains',
  headers: {'content-type': 'application/json'},
  body: {
    auditLogsEnabled: false,
    authorizedNetworks: [],
    createTime: '',
    fqdn: '',
    labels: {},
    locations: [],
    managedIdentitiesAdminName: '',
    name: '',
    reservedIpRange: '',
    state: '',
    statusMessage: '',
    trusts: [
      {
        createTime: '',
        lastKnownTrustConnectedHeartbeatTime: '',
        selectiveAuthentication: false,
        state: '',
        stateDescription: '',
        targetDnsIpAddresses: [],
        targetDomainName: '',
        trustDirection: '',
        trustHandshakeSecret: '',
        trustType: '',
        updateTime: ''
      }
    ],
    updateTime: ''
  },
  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}}/v1alpha1/:parent/domains');

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

req.type('json');
req.send({
  auditLogsEnabled: false,
  authorizedNetworks: [],
  createTime: '',
  fqdn: '',
  labels: {},
  locations: [],
  managedIdentitiesAdminName: '',
  name: '',
  reservedIpRange: '',
  state: '',
  statusMessage: '',
  trusts: [
    {
      createTime: '',
      lastKnownTrustConnectedHeartbeatTime: '',
      selectiveAuthentication: false,
      state: '',
      stateDescription: '',
      targetDnsIpAddresses: [],
      targetDomainName: '',
      trustDirection: '',
      trustHandshakeSecret: '',
      trustType: '',
      updateTime: ''
    }
  ],
  updateTime: ''
});

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}}/v1alpha1/:parent/domains',
  headers: {'content-type': 'application/json'},
  data: {
    auditLogsEnabled: false,
    authorizedNetworks: [],
    createTime: '',
    fqdn: '',
    labels: {},
    locations: [],
    managedIdentitiesAdminName: '',
    name: '',
    reservedIpRange: '',
    state: '',
    statusMessage: '',
    trusts: [
      {
        createTime: '',
        lastKnownTrustConnectedHeartbeatTime: '',
        selectiveAuthentication: false,
        state: '',
        stateDescription: '',
        targetDnsIpAddresses: [],
        targetDomainName: '',
        trustDirection: '',
        trustHandshakeSecret: '',
        trustType: '',
        updateTime: ''
      }
    ],
    updateTime: ''
  }
};

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

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

const url = '{{baseUrl}}/v1alpha1/:parent/domains';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"auditLogsEnabled":false,"authorizedNetworks":[],"createTime":"","fqdn":"","labels":{},"locations":[],"managedIdentitiesAdminName":"","name":"","reservedIpRange":"","state":"","statusMessage":"","trusts":[{"createTime":"","lastKnownTrustConnectedHeartbeatTime":"","selectiveAuthentication":false,"state":"","stateDescription":"","targetDnsIpAddresses":[],"targetDomainName":"","trustDirection":"","trustHandshakeSecret":"","trustType":"","updateTime":""}],"updateTime":""}'
};

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 = @{ @"auditLogsEnabled": @NO,
                              @"authorizedNetworks": @[  ],
                              @"createTime": @"",
                              @"fqdn": @"",
                              @"labels": @{  },
                              @"locations": @[  ],
                              @"managedIdentitiesAdminName": @"",
                              @"name": @"",
                              @"reservedIpRange": @"",
                              @"state": @"",
                              @"statusMessage": @"",
                              @"trusts": @[ @{ @"createTime": @"", @"lastKnownTrustConnectedHeartbeatTime": @"", @"selectiveAuthentication": @NO, @"state": @"", @"stateDescription": @"", @"targetDnsIpAddresses": @[  ], @"targetDomainName": @"", @"trustDirection": @"", @"trustHandshakeSecret": @"", @"trustType": @"", @"updateTime": @"" } ],
                              @"updateTime": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1alpha1/:parent/domains"]
                                                       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}}/v1alpha1/:parent/domains" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"auditLogsEnabled\": false,\n  \"authorizedNetworks\": [],\n  \"createTime\": \"\",\n  \"fqdn\": \"\",\n  \"labels\": {},\n  \"locations\": [],\n  \"managedIdentitiesAdminName\": \"\",\n  \"name\": \"\",\n  \"reservedIpRange\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"trusts\": [\n    {\n      \"createTime\": \"\",\n      \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n      \"selectiveAuthentication\": false,\n      \"state\": \"\",\n      \"stateDescription\": \"\",\n      \"targetDnsIpAddresses\": [],\n      \"targetDomainName\": \"\",\n      \"trustDirection\": \"\",\n      \"trustHandshakeSecret\": \"\",\n      \"trustType\": \"\",\n      \"updateTime\": \"\"\n    }\n  ],\n  \"updateTime\": \"\"\n}" in

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

 "{{baseUrl}}/v1alpha1/:parent/domains",
  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([
    'auditLogsEnabled' => null,
    'authorizedNetworks' => [
        
    ],
    'createTime' => '',
    'fqdn' => '',
    'labels' => [
        
    ],
    'locations' => [
        
    ],
    'managedIdentitiesAdminName' => '',
    'name' => '',
    'reservedIpRange' => '',
    'state' => '',
    'statusMessage' => '',
    'trusts' => [
        [
                'createTime' => '',
                'lastKnownTrustConnectedHeartbeatTime' => '',
                'selectiveAuthentication' => null,
                'state' => '',
                'stateDescription' => '',
                'targetDnsIpAddresses' => [
                                
                ],
                'targetDomainName' => '',
                'trustDirection' => '',
                'trustHandshakeSecret' => '',
                'trustType' => '',
                'updateTime' => ''
        ]
    ],
    'updateTime' => ''
  ]),
  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}}/v1alpha1/:parent/domains', [
  'body' => '{
  "auditLogsEnabled": false,
  "authorizedNetworks": [],
  "createTime": "",
  "fqdn": "",
  "labels": {},
  "locations": [],
  "managedIdentitiesAdminName": "",
  "name": "",
  "reservedIpRange": "",
  "state": "",
  "statusMessage": "",
  "trusts": [
    {
      "createTime": "",
      "lastKnownTrustConnectedHeartbeatTime": "",
      "selectiveAuthentication": false,
      "state": "",
      "stateDescription": "",
      "targetDnsIpAddresses": [],
      "targetDomainName": "",
      "trustDirection": "",
      "trustHandshakeSecret": "",
      "trustType": "",
      "updateTime": ""
    }
  ],
  "updateTime": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:parent/domains');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'auditLogsEnabled' => null,
  'authorizedNetworks' => [
    
  ],
  'createTime' => '',
  'fqdn' => '',
  'labels' => [
    
  ],
  'locations' => [
    
  ],
  'managedIdentitiesAdminName' => '',
  'name' => '',
  'reservedIpRange' => '',
  'state' => '',
  'statusMessage' => '',
  'trusts' => [
    [
        'createTime' => '',
        'lastKnownTrustConnectedHeartbeatTime' => '',
        'selectiveAuthentication' => null,
        'state' => '',
        'stateDescription' => '',
        'targetDnsIpAddresses' => [
                
        ],
        'targetDomainName' => '',
        'trustDirection' => '',
        'trustHandshakeSecret' => '',
        'trustType' => '',
        'updateTime' => ''
    ]
  ],
  'updateTime' => ''
]));

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

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

append(json_encode([
  'auditLogsEnabled' => null,
  'authorizedNetworks' => [
    
  ],
  'createTime' => '',
  'fqdn' => '',
  'labels' => [
    
  ],
  'locations' => [
    
  ],
  'managedIdentitiesAdminName' => '',
  'name' => '',
  'reservedIpRange' => '',
  'state' => '',
  'statusMessage' => '',
  'trusts' => [
    [
        'createTime' => '',
        'lastKnownTrustConnectedHeartbeatTime' => '',
        'selectiveAuthentication' => null,
        'state' => '',
        'stateDescription' => '',
        'targetDnsIpAddresses' => [
                
        ],
        'targetDomainName' => '',
        'trustDirection' => '',
        'trustHandshakeSecret' => '',
        'trustType' => '',
        'updateTime' => ''
    ]
  ],
  'updateTime' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1alpha1/:parent/domains');
$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}}/v1alpha1/:parent/domains' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "auditLogsEnabled": false,
  "authorizedNetworks": [],
  "createTime": "",
  "fqdn": "",
  "labels": {},
  "locations": [],
  "managedIdentitiesAdminName": "",
  "name": "",
  "reservedIpRange": "",
  "state": "",
  "statusMessage": "",
  "trusts": [
    {
      "createTime": "",
      "lastKnownTrustConnectedHeartbeatTime": "",
      "selectiveAuthentication": false,
      "state": "",
      "stateDescription": "",
      "targetDnsIpAddresses": [],
      "targetDomainName": "",
      "trustDirection": "",
      "trustHandshakeSecret": "",
      "trustType": "",
      "updateTime": ""
    }
  ],
  "updateTime": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:parent/domains' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "auditLogsEnabled": false,
  "authorizedNetworks": [],
  "createTime": "",
  "fqdn": "",
  "labels": {},
  "locations": [],
  "managedIdentitiesAdminName": "",
  "name": "",
  "reservedIpRange": "",
  "state": "",
  "statusMessage": "",
  "trusts": [
    {
      "createTime": "",
      "lastKnownTrustConnectedHeartbeatTime": "",
      "selectiveAuthentication": false,
      "state": "",
      "stateDescription": "",
      "targetDnsIpAddresses": [],
      "targetDomainName": "",
      "trustDirection": "",
      "trustHandshakeSecret": "",
      "trustType": "",
      "updateTime": ""
    }
  ],
  "updateTime": ""
}'

import http.client

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

payload = "{\n  \"auditLogsEnabled\": false,\n  \"authorizedNetworks\": [],\n  \"createTime\": \"\",\n  \"fqdn\": \"\",\n  \"labels\": {},\n  \"locations\": [],\n  \"managedIdentitiesAdminName\": \"\",\n  \"name\": \"\",\n  \"reservedIpRange\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"trusts\": [\n    {\n      \"createTime\": \"\",\n      \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n      \"selectiveAuthentication\": false,\n      \"state\": \"\",\n      \"stateDescription\": \"\",\n      \"targetDnsIpAddresses\": [],\n      \"targetDomainName\": \"\",\n      \"trustDirection\": \"\",\n      \"trustHandshakeSecret\": \"\",\n      \"trustType\": \"\",\n      \"updateTime\": \"\"\n    }\n  ],\n  \"updateTime\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v1alpha1/:parent/domains", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:parent/domains"

payload = {
    "auditLogsEnabled": False,
    "authorizedNetworks": [],
    "createTime": "",
    "fqdn": "",
    "labels": {},
    "locations": [],
    "managedIdentitiesAdminName": "",
    "name": "",
    "reservedIpRange": "",
    "state": "",
    "statusMessage": "",
    "trusts": [
        {
            "createTime": "",
            "lastKnownTrustConnectedHeartbeatTime": "",
            "selectiveAuthentication": False,
            "state": "",
            "stateDescription": "",
            "targetDnsIpAddresses": [],
            "targetDomainName": "",
            "trustDirection": "",
            "trustHandshakeSecret": "",
            "trustType": "",
            "updateTime": ""
        }
    ],
    "updateTime": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:parent/domains"

payload <- "{\n  \"auditLogsEnabled\": false,\n  \"authorizedNetworks\": [],\n  \"createTime\": \"\",\n  \"fqdn\": \"\",\n  \"labels\": {},\n  \"locations\": [],\n  \"managedIdentitiesAdminName\": \"\",\n  \"name\": \"\",\n  \"reservedIpRange\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"trusts\": [\n    {\n      \"createTime\": \"\",\n      \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n      \"selectiveAuthentication\": false,\n      \"state\": \"\",\n      \"stateDescription\": \"\",\n      \"targetDnsIpAddresses\": [],\n      \"targetDomainName\": \"\",\n      \"trustDirection\": \"\",\n      \"trustHandshakeSecret\": \"\",\n      \"trustType\": \"\",\n      \"updateTime\": \"\"\n    }\n  ],\n  \"updateTime\": \"\"\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}}/v1alpha1/:parent/domains")

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  \"auditLogsEnabled\": false,\n  \"authorizedNetworks\": [],\n  \"createTime\": \"\",\n  \"fqdn\": \"\",\n  \"labels\": {},\n  \"locations\": [],\n  \"managedIdentitiesAdminName\": \"\",\n  \"name\": \"\",\n  \"reservedIpRange\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"trusts\": [\n    {\n      \"createTime\": \"\",\n      \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n      \"selectiveAuthentication\": false,\n      \"state\": \"\",\n      \"stateDescription\": \"\",\n      \"targetDnsIpAddresses\": [],\n      \"targetDomainName\": \"\",\n      \"trustDirection\": \"\",\n      \"trustHandshakeSecret\": \"\",\n      \"trustType\": \"\",\n      \"updateTime\": \"\"\n    }\n  ],\n  \"updateTime\": \"\"\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/v1alpha1/:parent/domains') do |req|
  req.body = "{\n  \"auditLogsEnabled\": false,\n  \"authorizedNetworks\": [],\n  \"createTime\": \"\",\n  \"fqdn\": \"\",\n  \"labels\": {},\n  \"locations\": [],\n  \"managedIdentitiesAdminName\": \"\",\n  \"name\": \"\",\n  \"reservedIpRange\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"trusts\": [\n    {\n      \"createTime\": \"\",\n      \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n      \"selectiveAuthentication\": false,\n      \"state\": \"\",\n      \"stateDescription\": \"\",\n      \"targetDnsIpAddresses\": [],\n      \"targetDomainName\": \"\",\n      \"trustDirection\": \"\",\n      \"trustHandshakeSecret\": \"\",\n      \"trustType\": \"\",\n      \"updateTime\": \"\"\n    }\n  ],\n  \"updateTime\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1alpha1/:parent/domains";

    let payload = json!({
        "auditLogsEnabled": false,
        "authorizedNetworks": (),
        "createTime": "",
        "fqdn": "",
        "labels": json!({}),
        "locations": (),
        "managedIdentitiesAdminName": "",
        "name": "",
        "reservedIpRange": "",
        "state": "",
        "statusMessage": "",
        "trusts": (
            json!({
                "createTime": "",
                "lastKnownTrustConnectedHeartbeatTime": "",
                "selectiveAuthentication": false,
                "state": "",
                "stateDescription": "",
                "targetDnsIpAddresses": (),
                "targetDomainName": "",
                "trustDirection": "",
                "trustHandshakeSecret": "",
                "trustType": "",
                "updateTime": ""
            })
        ),
        "updateTime": ""
    });

    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 '{
  "auditLogsEnabled": false,
  "authorizedNetworks": [],
  "createTime": "",
  "fqdn": "",
  "labels": {},
  "locations": [],
  "managedIdentitiesAdminName": "",
  "name": "",
  "reservedIpRange": "",
  "state": "",
  "statusMessage": "",
  "trusts": [
    {
      "createTime": "",
      "lastKnownTrustConnectedHeartbeatTime": "",
      "selectiveAuthentication": false,
      "state": "",
      "stateDescription": "",
      "targetDnsIpAddresses": [],
      "targetDomainName": "",
      "trustDirection": "",
      "trustHandshakeSecret": "",
      "trustType": "",
      "updateTime": ""
    }
  ],
  "updateTime": ""
}' |  \
  http POST {{baseUrl}}/v1alpha1/:parent/domains \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "auditLogsEnabled": false,\n  "authorizedNetworks": [],\n  "createTime": "",\n  "fqdn": "",\n  "labels": {},\n  "locations": [],\n  "managedIdentitiesAdminName": "",\n  "name": "",\n  "reservedIpRange": "",\n  "state": "",\n  "statusMessage": "",\n  "trusts": [\n    {\n      "createTime": "",\n      "lastKnownTrustConnectedHeartbeatTime": "",\n      "selectiveAuthentication": false,\n      "state": "",\n      "stateDescription": "",\n      "targetDnsIpAddresses": [],\n      "targetDomainName": "",\n      "trustDirection": "",\n      "trustHandshakeSecret": "",\n      "trustType": "",\n      "updateTime": ""\n    }\n  ],\n  "updateTime": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1alpha1/:parent/domains

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "auditLogsEnabled": false,
  "authorizedNetworks": [],
  "createTime": "",
  "fqdn": "",
  "labels": [],
  "locations": [],
  "managedIdentitiesAdminName": "",
  "name": "",
  "reservedIpRange": "",
  "state": "",
  "statusMessage": "",
  "trusts": [
    [
      "createTime": "",
      "lastKnownTrustConnectedHeartbeatTime": "",
      "selectiveAuthentication": false,
      "state": "",
      "stateDescription": "",
      "targetDnsIpAddresses": [],
      "targetDomainName": "",
      "trustDirection": "",
      "trustHandshakeSecret": "",
      "trustType": "",
      "updateTime": ""
    ]
  ],
  "updateTime": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1alpha1/:parent/domains")! 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}}/v1alpha1/:name:detachTrust");

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  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1alpha1/:name:detachTrust" {:content-type :json
                                                                       :form-params {:trust {:createTime ""
                                                                                             :lastKnownTrustConnectedHeartbeatTime ""
                                                                                             :selectiveAuthentication false
                                                                                             :state ""
                                                                                             :stateDescription ""
                                                                                             :targetDnsIpAddresses []
                                                                                             :targetDomainName ""
                                                                                             :trustDirection ""
                                                                                             :trustHandshakeSecret ""
                                                                                             :trustType ""
                                                                                             :updateTime ""}}})

require "http/client"

url = "{{baseUrl}}/v1alpha1/:name:detachTrust"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\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}}/v1alpha1/:name:detachTrust"),
    Content = new StringContent("{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\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}}/v1alpha1/:name:detachTrust");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/:name:detachTrust"

	payload := strings.NewReader("{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\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/v1alpha1/:name:detachTrust HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 333

{
  "trust": {
    "createTime": "",
    "lastKnownTrustConnectedHeartbeatTime": "",
    "selectiveAuthentication": false,
    "state": "",
    "stateDescription": "",
    "targetDnsIpAddresses": [],
    "targetDomainName": "",
    "trustDirection": "",
    "trustHandshakeSecret": "",
    "trustType": "",
    "updateTime": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1alpha1/:name:detachTrust")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/:name:detachTrust"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\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  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:name:detachTrust")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1alpha1/:name:detachTrust")
  .header("content-type", "application/json")
  .body("{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  trust: {
    createTime: '',
    lastKnownTrustConnectedHeartbeatTime: '',
    selectiveAuthentication: false,
    state: '',
    stateDescription: '',
    targetDnsIpAddresses: [],
    targetDomainName: '',
    trustDirection: '',
    trustHandshakeSecret: '',
    trustType: '',
    updateTime: ''
  }
});

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

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

xhr.open('POST', '{{baseUrl}}/v1alpha1/:name:detachTrust');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:name:detachTrust',
  headers: {'content-type': 'application/json'},
  data: {
    trust: {
      createTime: '',
      lastKnownTrustConnectedHeartbeatTime: '',
      selectiveAuthentication: false,
      state: '',
      stateDescription: '',
      targetDnsIpAddresses: [],
      targetDomainName: '',
      trustDirection: '',
      trustHandshakeSecret: '',
      trustType: '',
      updateTime: ''
    }
  }
};

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

const url = '{{baseUrl}}/v1alpha1/:name:detachTrust';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"trust":{"createTime":"","lastKnownTrustConnectedHeartbeatTime":"","selectiveAuthentication":false,"state":"","stateDescription":"","targetDnsIpAddresses":[],"targetDomainName":"","trustDirection":"","trustHandshakeSecret":"","trustType":"","updateTime":""}}'
};

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}}/v1alpha1/:name:detachTrust',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "trust": {\n    "createTime": "",\n    "lastKnownTrustConnectedHeartbeatTime": "",\n    "selectiveAuthentication": false,\n    "state": "",\n    "stateDescription": "",\n    "targetDnsIpAddresses": [],\n    "targetDomainName": "",\n    "trustDirection": "",\n    "trustHandshakeSecret": "",\n    "trustType": "",\n    "updateTime": ""\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  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:name:detachTrust")
  .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/v1alpha1/:name:detachTrust',
  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({
  trust: {
    createTime: '',
    lastKnownTrustConnectedHeartbeatTime: '',
    selectiveAuthentication: false,
    state: '',
    stateDescription: '',
    targetDnsIpAddresses: [],
    targetDomainName: '',
    trustDirection: '',
    trustHandshakeSecret: '',
    trustType: '',
    updateTime: ''
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:name:detachTrust',
  headers: {'content-type': 'application/json'},
  body: {
    trust: {
      createTime: '',
      lastKnownTrustConnectedHeartbeatTime: '',
      selectiveAuthentication: false,
      state: '',
      stateDescription: '',
      targetDnsIpAddresses: [],
      targetDomainName: '',
      trustDirection: '',
      trustHandshakeSecret: '',
      trustType: '',
      updateTime: ''
    }
  },
  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}}/v1alpha1/:name:detachTrust');

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

req.type('json');
req.send({
  trust: {
    createTime: '',
    lastKnownTrustConnectedHeartbeatTime: '',
    selectiveAuthentication: false,
    state: '',
    stateDescription: '',
    targetDnsIpAddresses: [],
    targetDomainName: '',
    trustDirection: '',
    trustHandshakeSecret: '',
    trustType: '',
    updateTime: ''
  }
});

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}}/v1alpha1/:name:detachTrust',
  headers: {'content-type': 'application/json'},
  data: {
    trust: {
      createTime: '',
      lastKnownTrustConnectedHeartbeatTime: '',
      selectiveAuthentication: false,
      state: '',
      stateDescription: '',
      targetDnsIpAddresses: [],
      targetDomainName: '',
      trustDirection: '',
      trustHandshakeSecret: '',
      trustType: '',
      updateTime: ''
    }
  }
};

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

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

const url = '{{baseUrl}}/v1alpha1/:name:detachTrust';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"trust":{"createTime":"","lastKnownTrustConnectedHeartbeatTime":"","selectiveAuthentication":false,"state":"","stateDescription":"","targetDnsIpAddresses":[],"targetDomainName":"","trustDirection":"","trustHandshakeSecret":"","trustType":"","updateTime":""}}'
};

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 = @{ @"trust": @{ @"createTime": @"", @"lastKnownTrustConnectedHeartbeatTime": @"", @"selectiveAuthentication": @NO, @"state": @"", @"stateDescription": @"", @"targetDnsIpAddresses": @[  ], @"targetDomainName": @"", @"trustDirection": @"", @"trustHandshakeSecret": @"", @"trustType": @"", @"updateTime": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1alpha1/:name:detachTrust"]
                                                       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}}/v1alpha1/:name:detachTrust" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/v1alpha1/:name:detachTrust",
  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([
    'trust' => [
        'createTime' => '',
        'lastKnownTrustConnectedHeartbeatTime' => '',
        'selectiveAuthentication' => null,
        'state' => '',
        'stateDescription' => '',
        'targetDnsIpAddresses' => [
                
        ],
        'targetDomainName' => '',
        'trustDirection' => '',
        'trustHandshakeSecret' => '',
        'trustType' => '',
        'updateTime' => ''
    ]
  ]),
  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}}/v1alpha1/:name:detachTrust', [
  'body' => '{
  "trust": {
    "createTime": "",
    "lastKnownTrustConnectedHeartbeatTime": "",
    "selectiveAuthentication": false,
    "state": "",
    "stateDescription": "",
    "targetDnsIpAddresses": [],
    "targetDomainName": "",
    "trustDirection": "",
    "trustHandshakeSecret": "",
    "trustType": "",
    "updateTime": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:name:detachTrust');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'trust' => [
    'createTime' => '',
    'lastKnownTrustConnectedHeartbeatTime' => '',
    'selectiveAuthentication' => null,
    'state' => '',
    'stateDescription' => '',
    'targetDnsIpAddresses' => [
        
    ],
    'targetDomainName' => '',
    'trustDirection' => '',
    'trustHandshakeSecret' => '',
    'trustType' => '',
    'updateTime' => ''
  ]
]));

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

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

append(json_encode([
  'trust' => [
    'createTime' => '',
    'lastKnownTrustConnectedHeartbeatTime' => '',
    'selectiveAuthentication' => null,
    'state' => '',
    'stateDescription' => '',
    'targetDnsIpAddresses' => [
        
    ],
    'targetDomainName' => '',
    'trustDirection' => '',
    'trustHandshakeSecret' => '',
    'trustType' => '',
    'updateTime' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1alpha1/:name:detachTrust');
$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}}/v1alpha1/:name:detachTrust' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "trust": {
    "createTime": "",
    "lastKnownTrustConnectedHeartbeatTime": "",
    "selectiveAuthentication": false,
    "state": "",
    "stateDescription": "",
    "targetDnsIpAddresses": [],
    "targetDomainName": "",
    "trustDirection": "",
    "trustHandshakeSecret": "",
    "trustType": "",
    "updateTime": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:name:detachTrust' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "trust": {
    "createTime": "",
    "lastKnownTrustConnectedHeartbeatTime": "",
    "selectiveAuthentication": false,
    "state": "",
    "stateDescription": "",
    "targetDnsIpAddresses": [],
    "targetDomainName": "",
    "trustDirection": "",
    "trustHandshakeSecret": "",
    "trustType": "",
    "updateTime": ""
  }
}'

import http.client

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

payload = "{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\n  }\n}"

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

conn.request("POST", "/baseUrl/v1alpha1/:name:detachTrust", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:name:detachTrust"

payload = { "trust": {
        "createTime": "",
        "lastKnownTrustConnectedHeartbeatTime": "",
        "selectiveAuthentication": False,
        "state": "",
        "stateDescription": "",
        "targetDnsIpAddresses": [],
        "targetDomainName": "",
        "trustDirection": "",
        "trustHandshakeSecret": "",
        "trustType": "",
        "updateTime": ""
    } }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:name:detachTrust"

payload <- "{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\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}}/v1alpha1/:name:detachTrust")

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  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\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/v1alpha1/:name:detachTrust') do |req|
  req.body = "{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1alpha1/:name:detachTrust";

    let payload = json!({"trust": json!({
            "createTime": "",
            "lastKnownTrustConnectedHeartbeatTime": "",
            "selectiveAuthentication": false,
            "state": "",
            "stateDescription": "",
            "targetDnsIpAddresses": (),
            "targetDomainName": "",
            "trustDirection": "",
            "trustHandshakeSecret": "",
            "trustType": "",
            "updateTime": ""
        })});

    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 '{
  "trust": {
    "createTime": "",
    "lastKnownTrustConnectedHeartbeatTime": "",
    "selectiveAuthentication": false,
    "state": "",
    "stateDescription": "",
    "targetDnsIpAddresses": [],
    "targetDomainName": "",
    "trustDirection": "",
    "trustHandshakeSecret": "",
    "trustType": "",
    "updateTime": ""
  }
}' |  \
  http POST {{baseUrl}}/v1alpha1/:name:detachTrust \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "trust": {\n    "createTime": "",\n    "lastKnownTrustConnectedHeartbeatTime": "",\n    "selectiveAuthentication": false,\n    "state": "",\n    "stateDescription": "",\n    "targetDnsIpAddresses": [],\n    "targetDomainName": "",\n    "trustDirection": "",\n    "trustHandshakeSecret": "",\n    "trustType": "",\n    "updateTime": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/v1alpha1/:name:detachTrust

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["trust": [
    "createTime": "",
    "lastKnownTrustConnectedHeartbeatTime": "",
    "selectiveAuthentication": false,
    "state": "",
    "stateDescription": "",
    "targetDnsIpAddresses": [],
    "targetDomainName": "",
    "trustDirection": "",
    "trustHandshakeSecret": "",
    "trustType": "",
    "updateTime": ""
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1alpha1/:name:detachTrust")! 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}}/v1alpha1/:domain:disableMigration");

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}}/v1alpha1/:domain:disableMigration" {:content-type :json})

require "http/client"

url = "{{baseUrl}}/v1alpha1/:domain:disableMigration"
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}}/v1alpha1/:domain:disableMigration"),
    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}}/v1alpha1/:domain:disableMigration");
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}}/v1alpha1/:domain:disableMigration"

	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/v1alpha1/:domain:disableMigration HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 2

{}

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/:domain:disableMigration"))
    .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}}/v1alpha1/:domain:disableMigration")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1alpha1/:domain:disableMigration")
  .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}}/v1alpha1/:domain:disableMigration');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:domain:disableMigration',
  headers: {'content-type': 'application/json'},
  data: {}
};

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

const url = '{{baseUrl}}/v1alpha1/:domain:disableMigration';
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}}/v1alpha1/:domain:disableMigration',
  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}}/v1alpha1/:domain:disableMigration")
  .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/v1alpha1/:domain:disableMigration',
  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}}/v1alpha1/:domain:disableMigration',
  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}}/v1alpha1/:domain:disableMigration');

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}}/v1alpha1/:domain:disableMigration',
  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}}/v1alpha1/:domain:disableMigration';
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}}/v1alpha1/:domain:disableMigration"]
                                                       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}}/v1alpha1/:domain:disableMigration" 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}}/v1alpha1/:domain:disableMigration",
  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}}/v1alpha1/:domain:disableMigration', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:domain:disableMigration');
$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}}/v1alpha1/:domain:disableMigration');
$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}}/v1alpha1/:domain:disableMigration' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:domain:disableMigration' -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/v1alpha1/:domain:disableMigration", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:domain:disableMigration"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:domain:disableMigration"

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}}/v1alpha1/:domain:disableMigration")

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/v1alpha1/:domain:disableMigration') 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}}/v1alpha1/:domain:disableMigration";

    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}}/v1alpha1/:domain:disableMigration \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - {{baseUrl}}/v1alpha1/:domain:disableMigration

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}}/v1alpha1/:domain:disableMigration")! 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}}/v1alpha1/:domain:domainJoinMachine");

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  \"force\": false,\n  \"ouName\": \"\",\n  \"vmIdToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1alpha1/:domain:domainJoinMachine" {:content-type :json
                                                                               :form-params {:force false
                                                                                             :ouName ""
                                                                                             :vmIdToken ""}})

require "http/client"

url = "{{baseUrl}}/v1alpha1/:domain:domainJoinMachine"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"force\": false,\n  \"ouName\": \"\",\n  \"vmIdToken\": \"\"\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}}/v1alpha1/:domain:domainJoinMachine"),
    Content = new StringContent("{\n  \"force\": false,\n  \"ouName\": \"\",\n  \"vmIdToken\": \"\"\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}}/v1alpha1/:domain:domainJoinMachine");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"force\": false,\n  \"ouName\": \"\",\n  \"vmIdToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/:domain:domainJoinMachine"

	payload := strings.NewReader("{\n  \"force\": false,\n  \"ouName\": \"\",\n  \"vmIdToken\": \"\"\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/v1alpha1/:domain:domainJoinMachine HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 55

{
  "force": false,
  "ouName": "",
  "vmIdToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1alpha1/:domain:domainJoinMachine")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"force\": false,\n  \"ouName\": \"\",\n  \"vmIdToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/:domain:domainJoinMachine"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"force\": false,\n  \"ouName\": \"\",\n  \"vmIdToken\": \"\"\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  \"force\": false,\n  \"ouName\": \"\",\n  \"vmIdToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:domain:domainJoinMachine")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1alpha1/:domain:domainJoinMachine")
  .header("content-type", "application/json")
  .body("{\n  \"force\": false,\n  \"ouName\": \"\",\n  \"vmIdToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  force: false,
  ouName: '',
  vmIdToken: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/v1alpha1/:domain:domainJoinMachine');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:domain:domainJoinMachine',
  headers: {'content-type': 'application/json'},
  data: {force: false, ouName: '', vmIdToken: ''}
};

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

const url = '{{baseUrl}}/v1alpha1/:domain:domainJoinMachine';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"force":false,"ouName":"","vmIdToken":""}'
};

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}}/v1alpha1/:domain:domainJoinMachine',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "force": false,\n  "ouName": "",\n  "vmIdToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"force\": false,\n  \"ouName\": \"\",\n  \"vmIdToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:domain:domainJoinMachine")
  .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/v1alpha1/:domain:domainJoinMachine',
  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({force: false, ouName: '', vmIdToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:domain:domainJoinMachine',
  headers: {'content-type': 'application/json'},
  body: {force: false, ouName: '', vmIdToken: ''},
  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}}/v1alpha1/:domain:domainJoinMachine');

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

req.type('json');
req.send({
  force: false,
  ouName: '',
  vmIdToken: ''
});

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}}/v1alpha1/:domain:domainJoinMachine',
  headers: {'content-type': 'application/json'},
  data: {force: false, ouName: '', vmIdToken: ''}
};

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

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

const url = '{{baseUrl}}/v1alpha1/:domain:domainJoinMachine';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"force":false,"ouName":"","vmIdToken":""}'
};

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 = @{ @"force": @NO,
                              @"ouName": @"",
                              @"vmIdToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1alpha1/:domain:domainJoinMachine"]
                                                       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}}/v1alpha1/:domain:domainJoinMachine" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"force\": false,\n  \"ouName\": \"\",\n  \"vmIdToken\": \"\"\n}" in

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

 "{{baseUrl}}/v1alpha1/:domain:domainJoinMachine",
  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([
    'force' => null,
    'ouName' => '',
    'vmIdToken' => ''
  ]),
  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}}/v1alpha1/:domain:domainJoinMachine', [
  'body' => '{
  "force": false,
  "ouName": "",
  "vmIdToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:domain:domainJoinMachine');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'force' => null,
  'ouName' => '',
  'vmIdToken' => ''
]));

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

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

append(json_encode([
  'force' => null,
  'ouName' => '',
  'vmIdToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1alpha1/:domain:domainJoinMachine');
$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}}/v1alpha1/:domain:domainJoinMachine' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "force": false,
  "ouName": "",
  "vmIdToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:domain:domainJoinMachine' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "force": false,
  "ouName": "",
  "vmIdToken": ""
}'

import http.client

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

payload = "{\n  \"force\": false,\n  \"ouName\": \"\",\n  \"vmIdToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v1alpha1/:domain:domainJoinMachine", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:domain:domainJoinMachine"

payload = {
    "force": False,
    "ouName": "",
    "vmIdToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:domain:domainJoinMachine"

payload <- "{\n  \"force\": false,\n  \"ouName\": \"\",\n  \"vmIdToken\": \"\"\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}}/v1alpha1/:domain:domainJoinMachine")

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  \"force\": false,\n  \"ouName\": \"\",\n  \"vmIdToken\": \"\"\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/v1alpha1/:domain:domainJoinMachine') do |req|
  req.body = "{\n  \"force\": false,\n  \"ouName\": \"\",\n  \"vmIdToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1alpha1/:domain:domainJoinMachine";

    let payload = json!({
        "force": false,
        "ouName": "",
        "vmIdToken": ""
    });

    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 '{
  "force": false,
  "ouName": "",
  "vmIdToken": ""
}' |  \
  http POST {{baseUrl}}/v1alpha1/:domain:domainJoinMachine \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "force": false,\n  "ouName": "",\n  "vmIdToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1alpha1/:domain:domainJoinMachine

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "force": false,
  "ouName": "",
  "vmIdToken": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1alpha1/:domain:domainJoinMachine")! 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}}/v1alpha1/:domain:enableMigration");

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  \"migratingDomains\": [\n    {\n      \"disableSidFiltering\": false,\n      \"domainName\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1alpha1/:domain:enableMigration" {:content-type :json
                                                                             :form-params {:migratingDomains [{:disableSidFiltering false
                                                                                                               :domainName ""}]}})

require "http/client"

url = "{{baseUrl}}/v1alpha1/:domain:enableMigration"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"migratingDomains\": [\n    {\n      \"disableSidFiltering\": false,\n      \"domainName\": \"\"\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}}/v1alpha1/:domain:enableMigration"),
    Content = new StringContent("{\n  \"migratingDomains\": [\n    {\n      \"disableSidFiltering\": false,\n      \"domainName\": \"\"\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}}/v1alpha1/:domain:enableMigration");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"migratingDomains\": [\n    {\n      \"disableSidFiltering\": false,\n      \"domainName\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/:domain:enableMigration"

	payload := strings.NewReader("{\n  \"migratingDomains\": [\n    {\n      \"disableSidFiltering\": false,\n      \"domainName\": \"\"\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/v1alpha1/:domain:enableMigration HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 102

{
  "migratingDomains": [
    {
      "disableSidFiltering": false,
      "domainName": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1alpha1/:domain:enableMigration")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"migratingDomains\": [\n    {\n      \"disableSidFiltering\": false,\n      \"domainName\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/:domain:enableMigration"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"migratingDomains\": [\n    {\n      \"disableSidFiltering\": false,\n      \"domainName\": \"\"\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  \"migratingDomains\": [\n    {\n      \"disableSidFiltering\": false,\n      \"domainName\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:domain:enableMigration")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1alpha1/:domain:enableMigration")
  .header("content-type", "application/json")
  .body("{\n  \"migratingDomains\": [\n    {\n      \"disableSidFiltering\": false,\n      \"domainName\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  migratingDomains: [
    {
      disableSidFiltering: false,
      domainName: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/v1alpha1/:domain:enableMigration');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:domain:enableMigration',
  headers: {'content-type': 'application/json'},
  data: {migratingDomains: [{disableSidFiltering: false, domainName: ''}]}
};

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

const url = '{{baseUrl}}/v1alpha1/:domain:enableMigration';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"migratingDomains":[{"disableSidFiltering":false,"domainName":""}]}'
};

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}}/v1alpha1/:domain:enableMigration',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "migratingDomains": [\n    {\n      "disableSidFiltering": false,\n      "domainName": ""\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  \"migratingDomains\": [\n    {\n      \"disableSidFiltering\": false,\n      \"domainName\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:domain:enableMigration")
  .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/v1alpha1/:domain:enableMigration',
  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({migratingDomains: [{disableSidFiltering: false, domainName: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:domain:enableMigration',
  headers: {'content-type': 'application/json'},
  body: {migratingDomains: [{disableSidFiltering: false, domainName: ''}]},
  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}}/v1alpha1/:domain:enableMigration');

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

req.type('json');
req.send({
  migratingDomains: [
    {
      disableSidFiltering: false,
      domainName: ''
    }
  ]
});

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}}/v1alpha1/:domain:enableMigration',
  headers: {'content-type': 'application/json'},
  data: {migratingDomains: [{disableSidFiltering: false, domainName: ''}]}
};

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

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

const url = '{{baseUrl}}/v1alpha1/:domain:enableMigration';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"migratingDomains":[{"disableSidFiltering":false,"domainName":""}]}'
};

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 = @{ @"migratingDomains": @[ @{ @"disableSidFiltering": @NO, @"domainName": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1alpha1/:domain:enableMigration"]
                                                       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}}/v1alpha1/:domain:enableMigration" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"migratingDomains\": [\n    {\n      \"disableSidFiltering\": false,\n      \"domainName\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/v1alpha1/:domain:enableMigration",
  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([
    'migratingDomains' => [
        [
                'disableSidFiltering' => null,
                'domainName' => ''
        ]
    ]
  ]),
  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}}/v1alpha1/:domain:enableMigration', [
  'body' => '{
  "migratingDomains": [
    {
      "disableSidFiltering": false,
      "domainName": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:domain:enableMigration');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'migratingDomains' => [
    [
        'disableSidFiltering' => null,
        'domainName' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'migratingDomains' => [
    [
        'disableSidFiltering' => null,
        'domainName' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1alpha1/:domain:enableMigration');
$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}}/v1alpha1/:domain:enableMigration' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "migratingDomains": [
    {
      "disableSidFiltering": false,
      "domainName": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:domain:enableMigration' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "migratingDomains": [
    {
      "disableSidFiltering": false,
      "domainName": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"migratingDomains\": [\n    {\n      \"disableSidFiltering\": false,\n      \"domainName\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/v1alpha1/:domain:enableMigration", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:domain:enableMigration"

payload = { "migratingDomains": [
        {
            "disableSidFiltering": False,
            "domainName": ""
        }
    ] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:domain:enableMigration"

payload <- "{\n  \"migratingDomains\": [\n    {\n      \"disableSidFiltering\": false,\n      \"domainName\": \"\"\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}}/v1alpha1/:domain:enableMigration")

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  \"migratingDomains\": [\n    {\n      \"disableSidFiltering\": false,\n      \"domainName\": \"\"\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/v1alpha1/:domain:enableMigration') do |req|
  req.body = "{\n  \"migratingDomains\": [\n    {\n      \"disableSidFiltering\": false,\n      \"domainName\": \"\"\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}}/v1alpha1/:domain:enableMigration";

    let payload = json!({"migratingDomains": (
            json!({
                "disableSidFiltering": false,
                "domainName": ""
            })
        )});

    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 '{
  "migratingDomains": [
    {
      "disableSidFiltering": false,
      "domainName": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/v1alpha1/:domain:enableMigration \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "migratingDomains": [\n    {\n      "disableSidFiltering": false,\n      "domainName": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/v1alpha1/:domain:enableMigration

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["migratingDomains": [
    [
      "disableSidFiltering": false,
      "domainName": ""
    ]
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1alpha1/:domain:enableMigration")! 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}}/v1alpha1/:domain:extendSchema");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"description\": \"\",\n  \"fileContents\": \"\",\n  \"gcsPath\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1alpha1/:domain:extendSchema" {:content-type :json
                                                                          :form-params {:description ""
                                                                                        :fileContents ""
                                                                                        :gcsPath ""}})

require "http/client"

url = "{{baseUrl}}/v1alpha1/:domain:extendSchema"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"description\": \"\",\n  \"fileContents\": \"\",\n  \"gcsPath\": \"\"\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}}/v1alpha1/:domain:extendSchema"),
    Content = new StringContent("{\n  \"description\": \"\",\n  \"fileContents\": \"\",\n  \"gcsPath\": \"\"\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}}/v1alpha1/:domain:extendSchema");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"description\": \"\",\n  \"fileContents\": \"\",\n  \"gcsPath\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/:domain:extendSchema"

	payload := strings.NewReader("{\n  \"description\": \"\",\n  \"fileContents\": \"\",\n  \"gcsPath\": \"\"\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/v1alpha1/:domain:extendSchema HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 62

{
  "description": "",
  "fileContents": "",
  "gcsPath": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1alpha1/:domain:extendSchema")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"description\": \"\",\n  \"fileContents\": \"\",\n  \"gcsPath\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/:domain:extendSchema"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"description\": \"\",\n  \"fileContents\": \"\",\n  \"gcsPath\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"description\": \"\",\n  \"fileContents\": \"\",\n  \"gcsPath\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:domain:extendSchema")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1alpha1/:domain:extendSchema")
  .header("content-type", "application/json")
  .body("{\n  \"description\": \"\",\n  \"fileContents\": \"\",\n  \"gcsPath\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  description: '',
  fileContents: '',
  gcsPath: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/v1alpha1/:domain:extendSchema');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:domain:extendSchema',
  headers: {'content-type': 'application/json'},
  data: {description: '', fileContents: '', gcsPath: ''}
};

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

const url = '{{baseUrl}}/v1alpha1/:domain:extendSchema';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"description":"","fileContents":"","gcsPath":""}'
};

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}}/v1alpha1/:domain:extendSchema',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "description": "",\n  "fileContents": "",\n  "gcsPath": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"description\": \"\",\n  \"fileContents\": \"\",\n  \"gcsPath\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:domain:extendSchema")
  .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/v1alpha1/:domain:extendSchema',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({description: '', fileContents: '', gcsPath: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:domain:extendSchema',
  headers: {'content-type': 'application/json'},
  body: {description: '', fileContents: '', gcsPath: ''},
  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}}/v1alpha1/:domain:extendSchema');

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

req.type('json');
req.send({
  description: '',
  fileContents: '',
  gcsPath: ''
});

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}}/v1alpha1/:domain:extendSchema',
  headers: {'content-type': 'application/json'},
  data: {description: '', fileContents: '', gcsPath: ''}
};

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

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

const url = '{{baseUrl}}/v1alpha1/:domain:extendSchema';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"description":"","fileContents":"","gcsPath":""}'
};

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

#import 

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1alpha1/:domain:extendSchema"]
                                                       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}}/v1alpha1/:domain:extendSchema" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"description\": \"\",\n  \"fileContents\": \"\",\n  \"gcsPath\": \"\"\n}" in

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

 "{{baseUrl}}/v1alpha1/:domain:extendSchema",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'description' => '',
    'fileContents' => '',
    'gcsPath' => ''
  ]),
  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}}/v1alpha1/:domain:extendSchema', [
  'body' => '{
  "description": "",
  "fileContents": "",
  "gcsPath": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:domain:extendSchema');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'description' => '',
  'fileContents' => '',
  'gcsPath' => ''
]));

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

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

append(json_encode([
  'description' => '',
  'fileContents' => '',
  'gcsPath' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1alpha1/:domain:extendSchema');
$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}}/v1alpha1/:domain:extendSchema' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "fileContents": "",
  "gcsPath": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:domain:extendSchema' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "fileContents": "",
  "gcsPath": ""
}'

import http.client

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

payload = "{\n  \"description\": \"\",\n  \"fileContents\": \"\",\n  \"gcsPath\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v1alpha1/:domain:extendSchema", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:domain:extendSchema"

payload = {
    "description": "",
    "fileContents": "",
    "gcsPath": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:domain:extendSchema"

payload <- "{\n  \"description\": \"\",\n  \"fileContents\": \"\",\n  \"gcsPath\": \"\"\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}}/v1alpha1/:domain:extendSchema")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"description\": \"\",\n  \"fileContents\": \"\",\n  \"gcsPath\": \"\"\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/v1alpha1/:domain:extendSchema') do |req|
  req.body = "{\n  \"description\": \"\",\n  \"fileContents\": \"\",\n  \"gcsPath\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1alpha1/:domain:extendSchema";

    let payload = json!({
        "description": "",
        "fileContents": "",
        "gcsPath": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "description": "",
  "fileContents": "",
  "gcsPath": ""
}' |  \
  http POST {{baseUrl}}/v1alpha1/:domain:extendSchema \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "description": "",\n  "fileContents": "",\n  "gcsPath": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1alpha1/:domain:extendSchema

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1alpha1/:domain:extendSchema")! 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}}/v1alpha1/:name/ldapssettings");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1alpha1/:name/ldapssettings")

require "http/client"

url = "{{baseUrl}}/v1alpha1/:name/ldapssettings"

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}}/v1alpha1/:name/ldapssettings"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1alpha1/:name/ldapssettings");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/:name/ldapssettings"

	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/v1alpha1/:name/ldapssettings HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1alpha1/:name/ldapssettings")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/:name/ldapssettings"))
    .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}}/v1alpha1/:name/ldapssettings")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1alpha1/:name/ldapssettings")
  .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}}/v1alpha1/:name/ldapssettings');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1alpha1/:name/ldapssettings'};

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

const url = '{{baseUrl}}/v1alpha1/:name/ldapssettings';
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}}/v1alpha1/:name/ldapssettings',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:name/ldapssettings")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1alpha1/:name/ldapssettings',
  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}}/v1alpha1/:name/ldapssettings'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1alpha1/:name/ldapssettings');

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}}/v1alpha1/:name/ldapssettings'};

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

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

const url = '{{baseUrl}}/v1alpha1/:name/ldapssettings';
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}}/v1alpha1/:name/ldapssettings"]
                                                       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}}/v1alpha1/:name/ldapssettings" in

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

 "{{baseUrl}}/v1alpha1/:name/ldapssettings",
  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}}/v1alpha1/:name/ldapssettings');

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:name/ldapssettings');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1alpha1/:name/ldapssettings');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1alpha1/:name/ldapssettings' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:name/ldapssettings' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1alpha1/:name/ldapssettings")

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:name/ldapssettings"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:name/ldapssettings"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1alpha1/:name/ldapssettings")

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/v1alpha1/:name/ldapssettings') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1alpha1/:name/ldapssettings";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v1alpha1/:name/ldapssettings

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1alpha1/:name/ldapssettings

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1alpha1/:name/ldapssettings")! 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}}/v1alpha1/:parent/domains");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1alpha1/:parent/domains")

require "http/client"

url = "{{baseUrl}}/v1alpha1/:parent/domains"

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}}/v1alpha1/:parent/domains"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1alpha1/:parent/domains");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/:parent/domains"

	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/v1alpha1/:parent/domains HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1alpha1/:parent/domains")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/:parent/domains"))
    .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}}/v1alpha1/:parent/domains")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1alpha1/:parent/domains")
  .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}}/v1alpha1/:parent/domains');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1alpha1/:parent/domains'};

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

const url = '{{baseUrl}}/v1alpha1/:parent/domains';
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}}/v1alpha1/:parent/domains',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:parent/domains")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1alpha1/:parent/domains',
  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}}/v1alpha1/:parent/domains'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1alpha1/:parent/domains');

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}}/v1alpha1/:parent/domains'};

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

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

const url = '{{baseUrl}}/v1alpha1/:parent/domains';
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}}/v1alpha1/:parent/domains"]
                                                       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}}/v1alpha1/:parent/domains" in

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

 "{{baseUrl}}/v1alpha1/:parent/domains",
  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}}/v1alpha1/:parent/domains');

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:parent/domains');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1alpha1/:parent/domains');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1alpha1/:parent/domains' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:parent/domains' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1alpha1/:parent/domains")

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:parent/domains"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:parent/domains"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1alpha1/:parent/domains")

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/v1alpha1/:parent/domains') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1alpha1/:parent/domains";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v1alpha1/:parent/domains

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1alpha1/:parent/domains

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1alpha1/:parent/domains")! 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}}/v1alpha1/:name:reconfigureTrust");

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  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1alpha1/:name:reconfigureTrust" {:content-type :json
                                                                            :form-params {:trust {:createTime ""
                                                                                                  :lastKnownTrustConnectedHeartbeatTime ""
                                                                                                  :selectiveAuthentication false
                                                                                                  :state ""
                                                                                                  :stateDescription ""
                                                                                                  :targetDnsIpAddresses []
                                                                                                  :targetDomainName ""
                                                                                                  :trustDirection ""
                                                                                                  :trustHandshakeSecret ""
                                                                                                  :trustType ""
                                                                                                  :updateTime ""}}})

require "http/client"

url = "{{baseUrl}}/v1alpha1/:name:reconfigureTrust"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\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}}/v1alpha1/:name:reconfigureTrust"),
    Content = new StringContent("{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\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}}/v1alpha1/:name:reconfigureTrust");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/:name:reconfigureTrust"

	payload := strings.NewReader("{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\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/v1alpha1/:name:reconfigureTrust HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 333

{
  "trust": {
    "createTime": "",
    "lastKnownTrustConnectedHeartbeatTime": "",
    "selectiveAuthentication": false,
    "state": "",
    "stateDescription": "",
    "targetDnsIpAddresses": [],
    "targetDomainName": "",
    "trustDirection": "",
    "trustHandshakeSecret": "",
    "trustType": "",
    "updateTime": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1alpha1/:name:reconfigureTrust")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/:name:reconfigureTrust"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\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  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:name:reconfigureTrust")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1alpha1/:name:reconfigureTrust")
  .header("content-type", "application/json")
  .body("{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  trust: {
    createTime: '',
    lastKnownTrustConnectedHeartbeatTime: '',
    selectiveAuthentication: false,
    state: '',
    stateDescription: '',
    targetDnsIpAddresses: [],
    targetDomainName: '',
    trustDirection: '',
    trustHandshakeSecret: '',
    trustType: '',
    updateTime: ''
  }
});

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

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

xhr.open('POST', '{{baseUrl}}/v1alpha1/:name:reconfigureTrust');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:name:reconfigureTrust',
  headers: {'content-type': 'application/json'},
  data: {
    trust: {
      createTime: '',
      lastKnownTrustConnectedHeartbeatTime: '',
      selectiveAuthentication: false,
      state: '',
      stateDescription: '',
      targetDnsIpAddresses: [],
      targetDomainName: '',
      trustDirection: '',
      trustHandshakeSecret: '',
      trustType: '',
      updateTime: ''
    }
  }
};

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

const url = '{{baseUrl}}/v1alpha1/:name:reconfigureTrust';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"trust":{"createTime":"","lastKnownTrustConnectedHeartbeatTime":"","selectiveAuthentication":false,"state":"","stateDescription":"","targetDnsIpAddresses":[],"targetDomainName":"","trustDirection":"","trustHandshakeSecret":"","trustType":"","updateTime":""}}'
};

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}}/v1alpha1/:name:reconfigureTrust',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "trust": {\n    "createTime": "",\n    "lastKnownTrustConnectedHeartbeatTime": "",\n    "selectiveAuthentication": false,\n    "state": "",\n    "stateDescription": "",\n    "targetDnsIpAddresses": [],\n    "targetDomainName": "",\n    "trustDirection": "",\n    "trustHandshakeSecret": "",\n    "trustType": "",\n    "updateTime": ""\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  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:name:reconfigureTrust")
  .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/v1alpha1/:name:reconfigureTrust',
  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({
  trust: {
    createTime: '',
    lastKnownTrustConnectedHeartbeatTime: '',
    selectiveAuthentication: false,
    state: '',
    stateDescription: '',
    targetDnsIpAddresses: [],
    targetDomainName: '',
    trustDirection: '',
    trustHandshakeSecret: '',
    trustType: '',
    updateTime: ''
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:name:reconfigureTrust',
  headers: {'content-type': 'application/json'},
  body: {
    trust: {
      createTime: '',
      lastKnownTrustConnectedHeartbeatTime: '',
      selectiveAuthentication: false,
      state: '',
      stateDescription: '',
      targetDnsIpAddresses: [],
      targetDomainName: '',
      trustDirection: '',
      trustHandshakeSecret: '',
      trustType: '',
      updateTime: ''
    }
  },
  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}}/v1alpha1/:name:reconfigureTrust');

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

req.type('json');
req.send({
  trust: {
    createTime: '',
    lastKnownTrustConnectedHeartbeatTime: '',
    selectiveAuthentication: false,
    state: '',
    stateDescription: '',
    targetDnsIpAddresses: [],
    targetDomainName: '',
    trustDirection: '',
    trustHandshakeSecret: '',
    trustType: '',
    updateTime: ''
  }
});

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}}/v1alpha1/:name:reconfigureTrust',
  headers: {'content-type': 'application/json'},
  data: {
    trust: {
      createTime: '',
      lastKnownTrustConnectedHeartbeatTime: '',
      selectiveAuthentication: false,
      state: '',
      stateDescription: '',
      targetDnsIpAddresses: [],
      targetDomainName: '',
      trustDirection: '',
      trustHandshakeSecret: '',
      trustType: '',
      updateTime: ''
    }
  }
};

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

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

const url = '{{baseUrl}}/v1alpha1/:name:reconfigureTrust';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"trust":{"createTime":"","lastKnownTrustConnectedHeartbeatTime":"","selectiveAuthentication":false,"state":"","stateDescription":"","targetDnsIpAddresses":[],"targetDomainName":"","trustDirection":"","trustHandshakeSecret":"","trustType":"","updateTime":""}}'
};

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 = @{ @"trust": @{ @"createTime": @"", @"lastKnownTrustConnectedHeartbeatTime": @"", @"selectiveAuthentication": @NO, @"state": @"", @"stateDescription": @"", @"targetDnsIpAddresses": @[  ], @"targetDomainName": @"", @"trustDirection": @"", @"trustHandshakeSecret": @"", @"trustType": @"", @"updateTime": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1alpha1/:name:reconfigureTrust"]
                                                       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}}/v1alpha1/:name:reconfigureTrust" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/v1alpha1/:name:reconfigureTrust",
  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([
    'trust' => [
        'createTime' => '',
        'lastKnownTrustConnectedHeartbeatTime' => '',
        'selectiveAuthentication' => null,
        'state' => '',
        'stateDescription' => '',
        'targetDnsIpAddresses' => [
                
        ],
        'targetDomainName' => '',
        'trustDirection' => '',
        'trustHandshakeSecret' => '',
        'trustType' => '',
        'updateTime' => ''
    ]
  ]),
  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}}/v1alpha1/:name:reconfigureTrust', [
  'body' => '{
  "trust": {
    "createTime": "",
    "lastKnownTrustConnectedHeartbeatTime": "",
    "selectiveAuthentication": false,
    "state": "",
    "stateDescription": "",
    "targetDnsIpAddresses": [],
    "targetDomainName": "",
    "trustDirection": "",
    "trustHandshakeSecret": "",
    "trustType": "",
    "updateTime": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:name:reconfigureTrust');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'trust' => [
    'createTime' => '',
    'lastKnownTrustConnectedHeartbeatTime' => '',
    'selectiveAuthentication' => null,
    'state' => '',
    'stateDescription' => '',
    'targetDnsIpAddresses' => [
        
    ],
    'targetDomainName' => '',
    'trustDirection' => '',
    'trustHandshakeSecret' => '',
    'trustType' => '',
    'updateTime' => ''
  ]
]));

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

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

append(json_encode([
  'trust' => [
    'createTime' => '',
    'lastKnownTrustConnectedHeartbeatTime' => '',
    'selectiveAuthentication' => null,
    'state' => '',
    'stateDescription' => '',
    'targetDnsIpAddresses' => [
        
    ],
    'targetDomainName' => '',
    'trustDirection' => '',
    'trustHandshakeSecret' => '',
    'trustType' => '',
    'updateTime' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1alpha1/:name:reconfigureTrust');
$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}}/v1alpha1/:name:reconfigureTrust' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "trust": {
    "createTime": "",
    "lastKnownTrustConnectedHeartbeatTime": "",
    "selectiveAuthentication": false,
    "state": "",
    "stateDescription": "",
    "targetDnsIpAddresses": [],
    "targetDomainName": "",
    "trustDirection": "",
    "trustHandshakeSecret": "",
    "trustType": "",
    "updateTime": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:name:reconfigureTrust' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "trust": {
    "createTime": "",
    "lastKnownTrustConnectedHeartbeatTime": "",
    "selectiveAuthentication": false,
    "state": "",
    "stateDescription": "",
    "targetDnsIpAddresses": [],
    "targetDomainName": "",
    "trustDirection": "",
    "trustHandshakeSecret": "",
    "trustType": "",
    "updateTime": ""
  }
}'

import http.client

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

payload = "{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\n  }\n}"

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

conn.request("POST", "/baseUrl/v1alpha1/:name:reconfigureTrust", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:name:reconfigureTrust"

payload = { "trust": {
        "createTime": "",
        "lastKnownTrustConnectedHeartbeatTime": "",
        "selectiveAuthentication": False,
        "state": "",
        "stateDescription": "",
        "targetDnsIpAddresses": [],
        "targetDomainName": "",
        "trustDirection": "",
        "trustHandshakeSecret": "",
        "trustType": "",
        "updateTime": ""
    } }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:name:reconfigureTrust"

payload <- "{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\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}}/v1alpha1/:name:reconfigureTrust")

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  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\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/v1alpha1/:name:reconfigureTrust') do |req|
  req.body = "{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1alpha1/:name:reconfigureTrust";

    let payload = json!({"trust": json!({
            "createTime": "",
            "lastKnownTrustConnectedHeartbeatTime": "",
            "selectiveAuthentication": false,
            "state": "",
            "stateDescription": "",
            "targetDnsIpAddresses": (),
            "targetDomainName": "",
            "trustDirection": "",
            "trustHandshakeSecret": "",
            "trustType": "",
            "updateTime": ""
        })});

    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 '{
  "trust": {
    "createTime": "",
    "lastKnownTrustConnectedHeartbeatTime": "",
    "selectiveAuthentication": false,
    "state": "",
    "stateDescription": "",
    "targetDnsIpAddresses": [],
    "targetDomainName": "",
    "trustDirection": "",
    "trustHandshakeSecret": "",
    "trustType": "",
    "updateTime": ""
  }
}' |  \
  http POST {{baseUrl}}/v1alpha1/:name:reconfigureTrust \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "trust": {\n    "createTime": "",\n    "lastKnownTrustConnectedHeartbeatTime": "",\n    "selectiveAuthentication": false,\n    "state": "",\n    "stateDescription": "",\n    "targetDnsIpAddresses": [],\n    "targetDomainName": "",\n    "trustDirection": "",\n    "trustHandshakeSecret": "",\n    "trustType": "",\n    "updateTime": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/v1alpha1/:name:reconfigureTrust

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["trust": [
    "createTime": "",
    "lastKnownTrustConnectedHeartbeatTime": "",
    "selectiveAuthentication": false,
    "state": "",
    "stateDescription": "",
    "targetDnsIpAddresses": [],
    "targetDomainName": "",
    "trustDirection": "",
    "trustHandshakeSecret": "",
    "trustType": "",
    "updateTime": ""
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1alpha1/:name:reconfigureTrust")! 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}}/v1alpha1/:name:resetAdminPassword");

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}}/v1alpha1/:name:resetAdminPassword" {:content-type :json})

require "http/client"

url = "{{baseUrl}}/v1alpha1/:name:resetAdminPassword"
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}}/v1alpha1/:name:resetAdminPassword"),
    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}}/v1alpha1/:name:resetAdminPassword");
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}}/v1alpha1/:name:resetAdminPassword"

	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/v1alpha1/:name:resetAdminPassword HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 2

{}

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/:name:resetAdminPassword"))
    .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}}/v1alpha1/:name:resetAdminPassword")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1alpha1/:name:resetAdminPassword")
  .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}}/v1alpha1/:name:resetAdminPassword');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:name:resetAdminPassword',
  headers: {'content-type': 'application/json'},
  data: {}
};

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

const url = '{{baseUrl}}/v1alpha1/:name:resetAdminPassword';
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}}/v1alpha1/:name:resetAdminPassword',
  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}}/v1alpha1/:name:resetAdminPassword")
  .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/v1alpha1/:name:resetAdminPassword',
  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}}/v1alpha1/:name:resetAdminPassword',
  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}}/v1alpha1/:name:resetAdminPassword');

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}}/v1alpha1/:name:resetAdminPassword',
  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}}/v1alpha1/:name:resetAdminPassword';
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}}/v1alpha1/:name:resetAdminPassword"]
                                                       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}}/v1alpha1/:name:resetAdminPassword" 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}}/v1alpha1/:name:resetAdminPassword",
  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}}/v1alpha1/:name:resetAdminPassword', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:name:resetAdminPassword');
$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}}/v1alpha1/:name:resetAdminPassword');
$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}}/v1alpha1/:name:resetAdminPassword' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:name:resetAdminPassword' -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/v1alpha1/:name:resetAdminPassword", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:name:resetAdminPassword"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:name:resetAdminPassword"

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}}/v1alpha1/:name:resetAdminPassword")

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/v1alpha1/:name:resetAdminPassword') 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}}/v1alpha1/:name:resetAdminPassword";

    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}}/v1alpha1/:name:resetAdminPassword \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - {{baseUrl}}/v1alpha1/:name:resetAdminPassword

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}}/v1alpha1/:name:resetAdminPassword")! 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}}/v1alpha1/:name:restore");

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  \"backupId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1alpha1/:name:restore" {:content-type :json
                                                                   :form-params {:backupId ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/:name:restore"

	payload := strings.NewReader("{\n  \"backupId\": \"\"\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/v1alpha1/:name:restore HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 20

{
  "backupId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1alpha1/:name:restore")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"backupId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1alpha1/:name:restore")
  .header("content-type", "application/json")
  .body("{\n  \"backupId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  backupId: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/v1alpha1/:name:restore');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:name:restore',
  headers: {'content-type': 'application/json'},
  data: {backupId: ''}
};

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

const url = '{{baseUrl}}/v1alpha1/:name:restore';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"backupId":""}'
};

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}}/v1alpha1/:name:restore',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "backupId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"backupId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:name:restore")
  .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/v1alpha1/:name:restore',
  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({backupId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:name:restore',
  headers: {'content-type': 'application/json'},
  body: {backupId: ''},
  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}}/v1alpha1/:name:restore');

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

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

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}}/v1alpha1/:name:restore',
  headers: {'content-type': 'application/json'},
  data: {backupId: ''}
};

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

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

const url = '{{baseUrl}}/v1alpha1/:name:restore';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"backupId":""}'
};

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 = @{ @"backupId": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1alpha1/:name:restore"]
                                                       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}}/v1alpha1/:name:restore" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"backupId\": \"\"\n}" in

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

 "{{baseUrl}}/v1alpha1/:name:restore",
  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([
    'backupId' => ''
  ]),
  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}}/v1alpha1/:name:restore', [
  'body' => '{
  "backupId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:name:restore');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'backupId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1alpha1/:name:restore');
$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}}/v1alpha1/:name:restore' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "backupId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:name:restore' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "backupId": ""
}'

import http.client

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

payload = "{\n  \"backupId\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v1alpha1/:name:restore", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:name:restore"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:name:restore"

payload <- "{\n  \"backupId\": \"\"\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}}/v1alpha1/:name:restore")

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  \"backupId\": \"\"\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/v1alpha1/:name:restore') do |req|
  req.body = "{\n  \"backupId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1alpha1/:name:restore";

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

    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 '{
  "backupId": ""
}' |  \
  http POST {{baseUrl}}/v1alpha1/:name:restore \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "backupId": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1alpha1/:name:restore

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1alpha1/:name:restore")! 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}}/v1alpha1/:parent/sqlIntegrations");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1alpha1/:parent/sqlIntegrations")

require "http/client"

url = "{{baseUrl}}/v1alpha1/:parent/sqlIntegrations"

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}}/v1alpha1/:parent/sqlIntegrations"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1alpha1/:parent/sqlIntegrations");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/:parent/sqlIntegrations"

	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/v1alpha1/:parent/sqlIntegrations HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1alpha1/:parent/sqlIntegrations")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/:parent/sqlIntegrations"))
    .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}}/v1alpha1/:parent/sqlIntegrations")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1alpha1/:parent/sqlIntegrations")
  .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}}/v1alpha1/:parent/sqlIntegrations');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1alpha1/:parent/sqlIntegrations'
};

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

const url = '{{baseUrl}}/v1alpha1/:parent/sqlIntegrations';
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}}/v1alpha1/:parent/sqlIntegrations',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:parent/sqlIntegrations")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1alpha1/:parent/sqlIntegrations',
  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}}/v1alpha1/:parent/sqlIntegrations'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1alpha1/:parent/sqlIntegrations');

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}}/v1alpha1/:parent/sqlIntegrations'
};

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

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

const url = '{{baseUrl}}/v1alpha1/:parent/sqlIntegrations';
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}}/v1alpha1/:parent/sqlIntegrations"]
                                                       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}}/v1alpha1/:parent/sqlIntegrations" in

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

 "{{baseUrl}}/v1alpha1/:parent/sqlIntegrations",
  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}}/v1alpha1/:parent/sqlIntegrations');

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:parent/sqlIntegrations');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1alpha1/:parent/sqlIntegrations');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1alpha1/:parent/sqlIntegrations' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:parent/sqlIntegrations' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1alpha1/:parent/sqlIntegrations")

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:parent/sqlIntegrations"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:parent/sqlIntegrations"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1alpha1/:parent/sqlIntegrations")

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/v1alpha1/:parent/sqlIntegrations') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1alpha1/:parent/sqlIntegrations";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v1alpha1/:parent/sqlIntegrations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1alpha1/:parent/sqlIntegrations

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1alpha1/:parent/sqlIntegrations")! 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, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1alpha1/:name/ldapssettings");

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  \"certificate\": {\n    \"expireTime\": \"\",\n    \"issuingCertificate\": \"\",\n    \"subject\": \"\",\n    \"subjectAlternativeName\": [],\n    \"thumbprint\": \"\"\n  },\n  \"certificatePassword\": \"\",\n  \"certificatePfx\": \"\",\n  \"name\": \"\",\n  \"state\": \"\",\n  \"updateTime\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/v1alpha1/:name/ldapssettings" {:content-type :json
                                                                          :form-params {:certificate {:expireTime ""
                                                                                                      :issuingCertificate ""
                                                                                                      :subject ""
                                                                                                      :subjectAlternativeName []
                                                                                                      :thumbprint ""}
                                                                                        :certificatePassword ""
                                                                                        :certificatePfx ""
                                                                                        :name ""
                                                                                        :state ""
                                                                                        :updateTime ""}})

require "http/client"

url = "{{baseUrl}}/v1alpha1/:name/ldapssettings"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"certificate\": {\n    \"expireTime\": \"\",\n    \"issuingCertificate\": \"\",\n    \"subject\": \"\",\n    \"subjectAlternativeName\": [],\n    \"thumbprint\": \"\"\n  },\n  \"certificatePassword\": \"\",\n  \"certificatePfx\": \"\",\n  \"name\": \"\",\n  \"state\": \"\",\n  \"updateTime\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/v1alpha1/:name/ldapssettings"),
    Content = new StringContent("{\n  \"certificate\": {\n    \"expireTime\": \"\",\n    \"issuingCertificate\": \"\",\n    \"subject\": \"\",\n    \"subjectAlternativeName\": [],\n    \"thumbprint\": \"\"\n  },\n  \"certificatePassword\": \"\",\n  \"certificatePfx\": \"\",\n  \"name\": \"\",\n  \"state\": \"\",\n  \"updateTime\": \"\"\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}}/v1alpha1/:name/ldapssettings");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"certificate\": {\n    \"expireTime\": \"\",\n    \"issuingCertificate\": \"\",\n    \"subject\": \"\",\n    \"subjectAlternativeName\": [],\n    \"thumbprint\": \"\"\n  },\n  \"certificatePassword\": \"\",\n  \"certificatePfx\": \"\",\n  \"name\": \"\",\n  \"state\": \"\",\n  \"updateTime\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/:name/ldapssettings"

	payload := strings.NewReader("{\n  \"certificate\": {\n    \"expireTime\": \"\",\n    \"issuingCertificate\": \"\",\n    \"subject\": \"\",\n    \"subjectAlternativeName\": [],\n    \"thumbprint\": \"\"\n  },\n  \"certificatePassword\": \"\",\n  \"certificatePfx\": \"\",\n  \"name\": \"\",\n  \"state\": \"\",\n  \"updateTime\": \"\"\n}")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/v1alpha1/:name/ldapssettings HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 254

{
  "certificate": {
    "expireTime": "",
    "issuingCertificate": "",
    "subject": "",
    "subjectAlternativeName": [],
    "thumbprint": ""
  },
  "certificatePassword": "",
  "certificatePfx": "",
  "name": "",
  "state": "",
  "updateTime": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/v1alpha1/:name/ldapssettings")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"certificate\": {\n    \"expireTime\": \"\",\n    \"issuingCertificate\": \"\",\n    \"subject\": \"\",\n    \"subjectAlternativeName\": [],\n    \"thumbprint\": \"\"\n  },\n  \"certificatePassword\": \"\",\n  \"certificatePfx\": \"\",\n  \"name\": \"\",\n  \"state\": \"\",\n  \"updateTime\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/:name/ldapssettings"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"certificate\": {\n    \"expireTime\": \"\",\n    \"issuingCertificate\": \"\",\n    \"subject\": \"\",\n    \"subjectAlternativeName\": [],\n    \"thumbprint\": \"\"\n  },\n  \"certificatePassword\": \"\",\n  \"certificatePfx\": \"\",\n  \"name\": \"\",\n  \"state\": \"\",\n  \"updateTime\": \"\"\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  \"certificate\": {\n    \"expireTime\": \"\",\n    \"issuingCertificate\": \"\",\n    \"subject\": \"\",\n    \"subjectAlternativeName\": [],\n    \"thumbprint\": \"\"\n  },\n  \"certificatePassword\": \"\",\n  \"certificatePfx\": \"\",\n  \"name\": \"\",\n  \"state\": \"\",\n  \"updateTime\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:name/ldapssettings")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/v1alpha1/:name/ldapssettings")
  .header("content-type", "application/json")
  .body("{\n  \"certificate\": {\n    \"expireTime\": \"\",\n    \"issuingCertificate\": \"\",\n    \"subject\": \"\",\n    \"subjectAlternativeName\": [],\n    \"thumbprint\": \"\"\n  },\n  \"certificatePassword\": \"\",\n  \"certificatePfx\": \"\",\n  \"name\": \"\",\n  \"state\": \"\",\n  \"updateTime\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  certificate: {
    expireTime: '',
    issuingCertificate: '',
    subject: '',
    subjectAlternativeName: [],
    thumbprint: ''
  },
  certificatePassword: '',
  certificatePfx: '',
  name: '',
  state: '',
  updateTime: ''
});

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

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

xhr.open('PATCH', '{{baseUrl}}/v1alpha1/:name/ldapssettings');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v1alpha1/:name/ldapssettings',
  headers: {'content-type': 'application/json'},
  data: {
    certificate: {
      expireTime: '',
      issuingCertificate: '',
      subject: '',
      subjectAlternativeName: [],
      thumbprint: ''
    },
    certificatePassword: '',
    certificatePfx: '',
    name: '',
    state: '',
    updateTime: ''
  }
};

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

const url = '{{baseUrl}}/v1alpha1/:name/ldapssettings';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"certificate":{"expireTime":"","issuingCertificate":"","subject":"","subjectAlternativeName":[],"thumbprint":""},"certificatePassword":"","certificatePfx":"","name":"","state":"","updateTime":""}'
};

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}}/v1alpha1/:name/ldapssettings',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "certificate": {\n    "expireTime": "",\n    "issuingCertificate": "",\n    "subject": "",\n    "subjectAlternativeName": [],\n    "thumbprint": ""\n  },\n  "certificatePassword": "",\n  "certificatePfx": "",\n  "name": "",\n  "state": "",\n  "updateTime": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"certificate\": {\n    \"expireTime\": \"\",\n    \"issuingCertificate\": \"\",\n    \"subject\": \"\",\n    \"subjectAlternativeName\": [],\n    \"thumbprint\": \"\"\n  },\n  \"certificatePassword\": \"\",\n  \"certificatePfx\": \"\",\n  \"name\": \"\",\n  \"state\": \"\",\n  \"updateTime\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:name/ldapssettings")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1alpha1/:name/ldapssettings',
  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({
  certificate: {
    expireTime: '',
    issuingCertificate: '',
    subject: '',
    subjectAlternativeName: [],
    thumbprint: ''
  },
  certificatePassword: '',
  certificatePfx: '',
  name: '',
  state: '',
  updateTime: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v1alpha1/:name/ldapssettings',
  headers: {'content-type': 'application/json'},
  body: {
    certificate: {
      expireTime: '',
      issuingCertificate: '',
      subject: '',
      subjectAlternativeName: [],
      thumbprint: ''
    },
    certificatePassword: '',
    certificatePfx: '',
    name: '',
    state: '',
    updateTime: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/v1alpha1/:name/ldapssettings');

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

req.type('json');
req.send({
  certificate: {
    expireTime: '',
    issuingCertificate: '',
    subject: '',
    subjectAlternativeName: [],
    thumbprint: ''
  },
  certificatePassword: '',
  certificatePfx: '',
  name: '',
  state: '',
  updateTime: ''
});

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

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

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

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v1alpha1/:name/ldapssettings',
  headers: {'content-type': 'application/json'},
  data: {
    certificate: {
      expireTime: '',
      issuingCertificate: '',
      subject: '',
      subjectAlternativeName: [],
      thumbprint: ''
    },
    certificatePassword: '',
    certificatePfx: '',
    name: '',
    state: '',
    updateTime: ''
  }
};

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

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

const url = '{{baseUrl}}/v1alpha1/:name/ldapssettings';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"certificate":{"expireTime":"","issuingCertificate":"","subject":"","subjectAlternativeName":[],"thumbprint":""},"certificatePassword":"","certificatePfx":"","name":"","state":"","updateTime":""}'
};

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 = @{ @"certificate": @{ @"expireTime": @"", @"issuingCertificate": @"", @"subject": @"", @"subjectAlternativeName": @[  ], @"thumbprint": @"" },
                              @"certificatePassword": @"",
                              @"certificatePfx": @"",
                              @"name": @"",
                              @"state": @"",
                              @"updateTime": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1alpha1/:name/ldapssettings"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/v1alpha1/:name/ldapssettings" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"certificate\": {\n    \"expireTime\": \"\",\n    \"issuingCertificate\": \"\",\n    \"subject\": \"\",\n    \"subjectAlternativeName\": [],\n    \"thumbprint\": \"\"\n  },\n  \"certificatePassword\": \"\",\n  \"certificatePfx\": \"\",\n  \"name\": \"\",\n  \"state\": \"\",\n  \"updateTime\": \"\"\n}" in

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

 "{{baseUrl}}/v1alpha1/:name/ldapssettings",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'certificate' => [
        'expireTime' => '',
        'issuingCertificate' => '',
        'subject' => '',
        'subjectAlternativeName' => [
                
        ],
        'thumbprint' => ''
    ],
    'certificatePassword' => '',
    'certificatePfx' => '',
    'name' => '',
    'state' => '',
    'updateTime' => ''
  ]),
  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('PATCH', '{{baseUrl}}/v1alpha1/:name/ldapssettings', [
  'body' => '{
  "certificate": {
    "expireTime": "",
    "issuingCertificate": "",
    "subject": "",
    "subjectAlternativeName": [],
    "thumbprint": ""
  },
  "certificatePassword": "",
  "certificatePfx": "",
  "name": "",
  "state": "",
  "updateTime": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:name/ldapssettings');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'certificate' => [
    'expireTime' => '',
    'issuingCertificate' => '',
    'subject' => '',
    'subjectAlternativeName' => [
        
    ],
    'thumbprint' => ''
  ],
  'certificatePassword' => '',
  'certificatePfx' => '',
  'name' => '',
  'state' => '',
  'updateTime' => ''
]));

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

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

append(json_encode([
  'certificate' => [
    'expireTime' => '',
    'issuingCertificate' => '',
    'subject' => '',
    'subjectAlternativeName' => [
        
    ],
    'thumbprint' => ''
  ],
  'certificatePassword' => '',
  'certificatePfx' => '',
  'name' => '',
  'state' => '',
  'updateTime' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1alpha1/:name/ldapssettings');
$request->setRequestMethod('PATCH');
$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}}/v1alpha1/:name/ldapssettings' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "certificate": {
    "expireTime": "",
    "issuingCertificate": "",
    "subject": "",
    "subjectAlternativeName": [],
    "thumbprint": ""
  },
  "certificatePassword": "",
  "certificatePfx": "",
  "name": "",
  "state": "",
  "updateTime": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:name/ldapssettings' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "certificate": {
    "expireTime": "",
    "issuingCertificate": "",
    "subject": "",
    "subjectAlternativeName": [],
    "thumbprint": ""
  },
  "certificatePassword": "",
  "certificatePfx": "",
  "name": "",
  "state": "",
  "updateTime": ""
}'

import http.client

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

payload = "{\n  \"certificate\": {\n    \"expireTime\": \"\",\n    \"issuingCertificate\": \"\",\n    \"subject\": \"\",\n    \"subjectAlternativeName\": [],\n    \"thumbprint\": \"\"\n  },\n  \"certificatePassword\": \"\",\n  \"certificatePfx\": \"\",\n  \"name\": \"\",\n  \"state\": \"\",\n  \"updateTime\": \"\"\n}"

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

conn.request("PATCH", "/baseUrl/v1alpha1/:name/ldapssettings", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:name/ldapssettings"

payload = {
    "certificate": {
        "expireTime": "",
        "issuingCertificate": "",
        "subject": "",
        "subjectAlternativeName": [],
        "thumbprint": ""
    },
    "certificatePassword": "",
    "certificatePfx": "",
    "name": "",
    "state": "",
    "updateTime": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:name/ldapssettings"

payload <- "{\n  \"certificate\": {\n    \"expireTime\": \"\",\n    \"issuingCertificate\": \"\",\n    \"subject\": \"\",\n    \"subjectAlternativeName\": [],\n    \"thumbprint\": \"\"\n  },\n  \"certificatePassword\": \"\",\n  \"certificatePfx\": \"\",\n  \"name\": \"\",\n  \"state\": \"\",\n  \"updateTime\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1alpha1/:name/ldapssettings")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"certificate\": {\n    \"expireTime\": \"\",\n    \"issuingCertificate\": \"\",\n    \"subject\": \"\",\n    \"subjectAlternativeName\": [],\n    \"thumbprint\": \"\"\n  },\n  \"certificatePassword\": \"\",\n  \"certificatePfx\": \"\",\n  \"name\": \"\",\n  \"state\": \"\",\n  \"updateTime\": \"\"\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.patch('/baseUrl/v1alpha1/:name/ldapssettings') do |req|
  req.body = "{\n  \"certificate\": {\n    \"expireTime\": \"\",\n    \"issuingCertificate\": \"\",\n    \"subject\": \"\",\n    \"subjectAlternativeName\": [],\n    \"thumbprint\": \"\"\n  },\n  \"certificatePassword\": \"\",\n  \"certificatePfx\": \"\",\n  \"name\": \"\",\n  \"state\": \"\",\n  \"updateTime\": \"\"\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}}/v1alpha1/:name/ldapssettings";

    let payload = json!({
        "certificate": json!({
            "expireTime": "",
            "issuingCertificate": "",
            "subject": "",
            "subjectAlternativeName": (),
            "thumbprint": ""
        }),
        "certificatePassword": "",
        "certificatePfx": "",
        "name": "",
        "state": "",
        "updateTime": ""
    });

    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("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

echo '{
  "certificate": {
    "expireTime": "",
    "issuingCertificate": "",
    "subject": "",
    "subjectAlternativeName": [],
    "thumbprint": ""
  },
  "certificatePassword": "",
  "certificatePfx": "",
  "name": "",
  "state": "",
  "updateTime": ""
}' |  \
  http PATCH {{baseUrl}}/v1alpha1/:name/ldapssettings \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "certificate": {\n    "expireTime": "",\n    "issuingCertificate": "",\n    "subject": "",\n    "subjectAlternativeName": [],\n    "thumbprint": ""\n  },\n  "certificatePassword": "",\n  "certificatePfx": "",\n  "name": "",\n  "state": "",\n  "updateTime": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1alpha1/:name/ldapssettings

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "certificate": [
    "expireTime": "",
    "issuingCertificate": "",
    "subject": "",
    "subjectAlternativeName": [],
    "thumbprint": ""
  ],
  "certificatePassword": "",
  "certificatePfx": "",
  "name": "",
  "state": "",
  "updateTime": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1alpha1/:name/ldapssettings")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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}}/v1alpha1/:name:validateTrust");

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  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1alpha1/:name:validateTrust" {:content-type :json
                                                                         :form-params {:trust {:createTime ""
                                                                                               :lastKnownTrustConnectedHeartbeatTime ""
                                                                                               :selectiveAuthentication false
                                                                                               :state ""
                                                                                               :stateDescription ""
                                                                                               :targetDnsIpAddresses []
                                                                                               :targetDomainName ""
                                                                                               :trustDirection ""
                                                                                               :trustHandshakeSecret ""
                                                                                               :trustType ""
                                                                                               :updateTime ""}}})

require "http/client"

url = "{{baseUrl}}/v1alpha1/:name:validateTrust"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\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}}/v1alpha1/:name:validateTrust"),
    Content = new StringContent("{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\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}}/v1alpha1/:name:validateTrust");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/:name:validateTrust"

	payload := strings.NewReader("{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\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/v1alpha1/:name:validateTrust HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 333

{
  "trust": {
    "createTime": "",
    "lastKnownTrustConnectedHeartbeatTime": "",
    "selectiveAuthentication": false,
    "state": "",
    "stateDescription": "",
    "targetDnsIpAddresses": [],
    "targetDomainName": "",
    "trustDirection": "",
    "trustHandshakeSecret": "",
    "trustType": "",
    "updateTime": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1alpha1/:name:validateTrust")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/:name:validateTrust"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\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  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:name:validateTrust")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1alpha1/:name:validateTrust")
  .header("content-type", "application/json")
  .body("{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  trust: {
    createTime: '',
    lastKnownTrustConnectedHeartbeatTime: '',
    selectiveAuthentication: false,
    state: '',
    stateDescription: '',
    targetDnsIpAddresses: [],
    targetDomainName: '',
    trustDirection: '',
    trustHandshakeSecret: '',
    trustType: '',
    updateTime: ''
  }
});

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

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

xhr.open('POST', '{{baseUrl}}/v1alpha1/:name:validateTrust');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:name:validateTrust',
  headers: {'content-type': 'application/json'},
  data: {
    trust: {
      createTime: '',
      lastKnownTrustConnectedHeartbeatTime: '',
      selectiveAuthentication: false,
      state: '',
      stateDescription: '',
      targetDnsIpAddresses: [],
      targetDomainName: '',
      trustDirection: '',
      trustHandshakeSecret: '',
      trustType: '',
      updateTime: ''
    }
  }
};

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

const url = '{{baseUrl}}/v1alpha1/:name:validateTrust';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"trust":{"createTime":"","lastKnownTrustConnectedHeartbeatTime":"","selectiveAuthentication":false,"state":"","stateDescription":"","targetDnsIpAddresses":[],"targetDomainName":"","trustDirection":"","trustHandshakeSecret":"","trustType":"","updateTime":""}}'
};

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}}/v1alpha1/:name:validateTrust',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "trust": {\n    "createTime": "",\n    "lastKnownTrustConnectedHeartbeatTime": "",\n    "selectiveAuthentication": false,\n    "state": "",\n    "stateDescription": "",\n    "targetDnsIpAddresses": [],\n    "targetDomainName": "",\n    "trustDirection": "",\n    "trustHandshakeSecret": "",\n    "trustType": "",\n    "updateTime": ""\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  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:name:validateTrust")
  .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/v1alpha1/:name:validateTrust',
  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({
  trust: {
    createTime: '',
    lastKnownTrustConnectedHeartbeatTime: '',
    selectiveAuthentication: false,
    state: '',
    stateDescription: '',
    targetDnsIpAddresses: [],
    targetDomainName: '',
    trustDirection: '',
    trustHandshakeSecret: '',
    trustType: '',
    updateTime: ''
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:name:validateTrust',
  headers: {'content-type': 'application/json'},
  body: {
    trust: {
      createTime: '',
      lastKnownTrustConnectedHeartbeatTime: '',
      selectiveAuthentication: false,
      state: '',
      stateDescription: '',
      targetDnsIpAddresses: [],
      targetDomainName: '',
      trustDirection: '',
      trustHandshakeSecret: '',
      trustType: '',
      updateTime: ''
    }
  },
  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}}/v1alpha1/:name:validateTrust');

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

req.type('json');
req.send({
  trust: {
    createTime: '',
    lastKnownTrustConnectedHeartbeatTime: '',
    selectiveAuthentication: false,
    state: '',
    stateDescription: '',
    targetDnsIpAddresses: [],
    targetDomainName: '',
    trustDirection: '',
    trustHandshakeSecret: '',
    trustType: '',
    updateTime: ''
  }
});

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}}/v1alpha1/:name:validateTrust',
  headers: {'content-type': 'application/json'},
  data: {
    trust: {
      createTime: '',
      lastKnownTrustConnectedHeartbeatTime: '',
      selectiveAuthentication: false,
      state: '',
      stateDescription: '',
      targetDnsIpAddresses: [],
      targetDomainName: '',
      trustDirection: '',
      trustHandshakeSecret: '',
      trustType: '',
      updateTime: ''
    }
  }
};

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

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

const url = '{{baseUrl}}/v1alpha1/:name:validateTrust';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"trust":{"createTime":"","lastKnownTrustConnectedHeartbeatTime":"","selectiveAuthentication":false,"state":"","stateDescription":"","targetDnsIpAddresses":[],"targetDomainName":"","trustDirection":"","trustHandshakeSecret":"","trustType":"","updateTime":""}}'
};

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 = @{ @"trust": @{ @"createTime": @"", @"lastKnownTrustConnectedHeartbeatTime": @"", @"selectiveAuthentication": @NO, @"state": @"", @"stateDescription": @"", @"targetDnsIpAddresses": @[  ], @"targetDomainName": @"", @"trustDirection": @"", @"trustHandshakeSecret": @"", @"trustType": @"", @"updateTime": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1alpha1/:name:validateTrust"]
                                                       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}}/v1alpha1/:name:validateTrust" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/v1alpha1/:name:validateTrust",
  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([
    'trust' => [
        'createTime' => '',
        'lastKnownTrustConnectedHeartbeatTime' => '',
        'selectiveAuthentication' => null,
        'state' => '',
        'stateDescription' => '',
        'targetDnsIpAddresses' => [
                
        ],
        'targetDomainName' => '',
        'trustDirection' => '',
        'trustHandshakeSecret' => '',
        'trustType' => '',
        'updateTime' => ''
    ]
  ]),
  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}}/v1alpha1/:name:validateTrust', [
  'body' => '{
  "trust": {
    "createTime": "",
    "lastKnownTrustConnectedHeartbeatTime": "",
    "selectiveAuthentication": false,
    "state": "",
    "stateDescription": "",
    "targetDnsIpAddresses": [],
    "targetDomainName": "",
    "trustDirection": "",
    "trustHandshakeSecret": "",
    "trustType": "",
    "updateTime": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:name:validateTrust');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'trust' => [
    'createTime' => '',
    'lastKnownTrustConnectedHeartbeatTime' => '',
    'selectiveAuthentication' => null,
    'state' => '',
    'stateDescription' => '',
    'targetDnsIpAddresses' => [
        
    ],
    'targetDomainName' => '',
    'trustDirection' => '',
    'trustHandshakeSecret' => '',
    'trustType' => '',
    'updateTime' => ''
  ]
]));

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

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

append(json_encode([
  'trust' => [
    'createTime' => '',
    'lastKnownTrustConnectedHeartbeatTime' => '',
    'selectiveAuthentication' => null,
    'state' => '',
    'stateDescription' => '',
    'targetDnsIpAddresses' => [
        
    ],
    'targetDomainName' => '',
    'trustDirection' => '',
    'trustHandshakeSecret' => '',
    'trustType' => '',
    'updateTime' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1alpha1/:name:validateTrust');
$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}}/v1alpha1/:name:validateTrust' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "trust": {
    "createTime": "",
    "lastKnownTrustConnectedHeartbeatTime": "",
    "selectiveAuthentication": false,
    "state": "",
    "stateDescription": "",
    "targetDnsIpAddresses": [],
    "targetDomainName": "",
    "trustDirection": "",
    "trustHandshakeSecret": "",
    "trustType": "",
    "updateTime": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:name:validateTrust' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "trust": {
    "createTime": "",
    "lastKnownTrustConnectedHeartbeatTime": "",
    "selectiveAuthentication": false,
    "state": "",
    "stateDescription": "",
    "targetDnsIpAddresses": [],
    "targetDomainName": "",
    "trustDirection": "",
    "trustHandshakeSecret": "",
    "trustType": "",
    "updateTime": ""
  }
}'

import http.client

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

payload = "{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\n  }\n}"

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

conn.request("POST", "/baseUrl/v1alpha1/:name:validateTrust", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:name:validateTrust"

payload = { "trust": {
        "createTime": "",
        "lastKnownTrustConnectedHeartbeatTime": "",
        "selectiveAuthentication": False,
        "state": "",
        "stateDescription": "",
        "targetDnsIpAddresses": [],
        "targetDomainName": "",
        "trustDirection": "",
        "trustHandshakeSecret": "",
        "trustType": "",
        "updateTime": ""
    } }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:name:validateTrust"

payload <- "{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\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}}/v1alpha1/:name:validateTrust")

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  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\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/v1alpha1/:name:validateTrust') do |req|
  req.body = "{\n  \"trust\": {\n    \"createTime\": \"\",\n    \"lastKnownTrustConnectedHeartbeatTime\": \"\",\n    \"selectiveAuthentication\": false,\n    \"state\": \"\",\n    \"stateDescription\": \"\",\n    \"targetDnsIpAddresses\": [],\n    \"targetDomainName\": \"\",\n    \"trustDirection\": \"\",\n    \"trustHandshakeSecret\": \"\",\n    \"trustType\": \"\",\n    \"updateTime\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1alpha1/:name:validateTrust";

    let payload = json!({"trust": json!({
            "createTime": "",
            "lastKnownTrustConnectedHeartbeatTime": "",
            "selectiveAuthentication": false,
            "state": "",
            "stateDescription": "",
            "targetDnsIpAddresses": (),
            "targetDomainName": "",
            "trustDirection": "",
            "trustHandshakeSecret": "",
            "trustType": "",
            "updateTime": ""
        })});

    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 '{
  "trust": {
    "createTime": "",
    "lastKnownTrustConnectedHeartbeatTime": "",
    "selectiveAuthentication": false,
    "state": "",
    "stateDescription": "",
    "targetDnsIpAddresses": [],
    "targetDomainName": "",
    "trustDirection": "",
    "trustHandshakeSecret": "",
    "trustType": "",
    "updateTime": ""
  }
}' |  \
  http POST {{baseUrl}}/v1alpha1/:name:validateTrust \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "trust": {\n    "createTime": "",\n    "lastKnownTrustConnectedHeartbeatTime": "",\n    "selectiveAuthentication": false,\n    "state": "",\n    "stateDescription": "",\n    "targetDnsIpAddresses": [],\n    "targetDomainName": "",\n    "trustDirection": "",\n    "trustHandshakeSecret": "",\n    "trustType": "",\n    "updateTime": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/v1alpha1/:name:validateTrust

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["trust": [
    "createTime": "",
    "lastKnownTrustConnectedHeartbeatTime": "",
    "selectiveAuthentication": false,
    "state": "",
    "stateDescription": "",
    "targetDnsIpAddresses": [],
    "targetDomainName": "",
    "trustDirection": "",
    "trustHandshakeSecret": "",
    "trustType": "",
    "updateTime": ""
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1alpha1/:name:validateTrust")! 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}}/v1alpha1/:name:cancel");

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}}/v1alpha1/:name:cancel" {:content-type :json})

require "http/client"

url = "{{baseUrl}}/v1alpha1/:name:cancel"
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}}/v1alpha1/:name:cancel"),
    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}}/v1alpha1/:name:cancel");
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}}/v1alpha1/:name:cancel"

	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/v1alpha1/:name:cancel HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 2

{}

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/:name:cancel"))
    .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}}/v1alpha1/:name:cancel")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1alpha1/:name:cancel")
  .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}}/v1alpha1/:name:cancel');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:name:cancel',
  headers: {'content-type': 'application/json'},
  data: {}
};

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

const url = '{{baseUrl}}/v1alpha1/:name:cancel';
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}}/v1alpha1/:name:cancel',
  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}}/v1alpha1/:name:cancel")
  .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/v1alpha1/:name:cancel',
  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}}/v1alpha1/:name:cancel',
  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}}/v1alpha1/:name:cancel');

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}}/v1alpha1/:name:cancel',
  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}}/v1alpha1/:name:cancel';
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}}/v1alpha1/:name:cancel"]
                                                       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}}/v1alpha1/:name:cancel" 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}}/v1alpha1/:name:cancel",
  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}}/v1alpha1/:name:cancel', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:name:cancel');
$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}}/v1alpha1/:name:cancel');
$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}}/v1alpha1/:name:cancel' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:name:cancel' -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/v1alpha1/:name:cancel", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:name:cancel"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:name:cancel"

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}}/v1alpha1/:name:cancel")

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/v1alpha1/:name:cancel') 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}}/v1alpha1/:name:cancel";

    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}}/v1alpha1/:name:cancel \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - {{baseUrl}}/v1alpha1/:name:cancel

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}}/v1alpha1/:name:cancel")! 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}}/v1alpha1/:name/operations");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1alpha1/:name/operations")

require "http/client"

url = "{{baseUrl}}/v1alpha1/:name/operations"

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}}/v1alpha1/:name/operations"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1alpha1/:name/operations");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/:name/operations"

	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/v1alpha1/:name/operations HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1alpha1/:name/operations")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/:name/operations"))
    .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}}/v1alpha1/:name/operations")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1alpha1/:name/operations")
  .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}}/v1alpha1/:name/operations');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1alpha1/:name/operations'};

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

const url = '{{baseUrl}}/v1alpha1/:name/operations';
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}}/v1alpha1/:name/operations',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:name/operations")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1alpha1/:name/operations',
  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}}/v1alpha1/:name/operations'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1alpha1/:name/operations');

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}}/v1alpha1/:name/operations'};

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

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

const url = '{{baseUrl}}/v1alpha1/:name/operations';
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}}/v1alpha1/:name/operations"]
                                                       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}}/v1alpha1/:name/operations" in

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

 "{{baseUrl}}/v1alpha1/:name/operations",
  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}}/v1alpha1/:name/operations');

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:name/operations');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1alpha1/:name/operations');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1alpha1/:name/operations' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:name/operations' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1alpha1/:name/operations")

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:name/operations"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:name/operations"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1alpha1/:name/operations")

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/v1alpha1/:name/operations') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1alpha1/:name/operations";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v1alpha1/:name/operations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1alpha1/:name/operations

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1alpha1/:name/operations")! 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}}/v1alpha1/:parent/peerings");

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  \"authorizedNetwork\": \"\",\n  \"createTime\": \"\",\n  \"domainResource\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"updateTime\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1alpha1/:parent/peerings" {:content-type :json
                                                                      :form-params {:authorizedNetwork ""
                                                                                    :createTime ""
                                                                                    :domainResource ""
                                                                                    :labels {}
                                                                                    :name ""
                                                                                    :state ""
                                                                                    :statusMessage ""
                                                                                    :updateTime ""}})

require "http/client"

url = "{{baseUrl}}/v1alpha1/:parent/peerings"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"authorizedNetwork\": \"\",\n  \"createTime\": \"\",\n  \"domainResource\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"updateTime\": \"\"\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}}/v1alpha1/:parent/peerings"),
    Content = new StringContent("{\n  \"authorizedNetwork\": \"\",\n  \"createTime\": \"\",\n  \"domainResource\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"updateTime\": \"\"\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}}/v1alpha1/:parent/peerings");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"authorizedNetwork\": \"\",\n  \"createTime\": \"\",\n  \"domainResource\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"updateTime\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/:parent/peerings"

	payload := strings.NewReader("{\n  \"authorizedNetwork\": \"\",\n  \"createTime\": \"\",\n  \"domainResource\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"updateTime\": \"\"\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/v1alpha1/:parent/peerings HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 161

{
  "authorizedNetwork": "",
  "createTime": "",
  "domainResource": "",
  "labels": {},
  "name": "",
  "state": "",
  "statusMessage": "",
  "updateTime": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1alpha1/:parent/peerings")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"authorizedNetwork\": \"\",\n  \"createTime\": \"\",\n  \"domainResource\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"updateTime\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/:parent/peerings"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"authorizedNetwork\": \"\",\n  \"createTime\": \"\",\n  \"domainResource\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"updateTime\": \"\"\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  \"authorizedNetwork\": \"\",\n  \"createTime\": \"\",\n  \"domainResource\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"updateTime\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:parent/peerings")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1alpha1/:parent/peerings")
  .header("content-type", "application/json")
  .body("{\n  \"authorizedNetwork\": \"\",\n  \"createTime\": \"\",\n  \"domainResource\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"updateTime\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  authorizedNetwork: '',
  createTime: '',
  domainResource: '',
  labels: {},
  name: '',
  state: '',
  statusMessage: '',
  updateTime: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/v1alpha1/:parent/peerings');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:parent/peerings',
  headers: {'content-type': 'application/json'},
  data: {
    authorizedNetwork: '',
    createTime: '',
    domainResource: '',
    labels: {},
    name: '',
    state: '',
    statusMessage: '',
    updateTime: ''
  }
};

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

const url = '{{baseUrl}}/v1alpha1/:parent/peerings';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"authorizedNetwork":"","createTime":"","domainResource":"","labels":{},"name":"","state":"","statusMessage":"","updateTime":""}'
};

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}}/v1alpha1/:parent/peerings',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "authorizedNetwork": "",\n  "createTime": "",\n  "domainResource": "",\n  "labels": {},\n  "name": "",\n  "state": "",\n  "statusMessage": "",\n  "updateTime": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"authorizedNetwork\": \"\",\n  \"createTime\": \"\",\n  \"domainResource\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"updateTime\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:parent/peerings")
  .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/v1alpha1/:parent/peerings',
  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({
  authorizedNetwork: '',
  createTime: '',
  domainResource: '',
  labels: {},
  name: '',
  state: '',
  statusMessage: '',
  updateTime: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:parent/peerings',
  headers: {'content-type': 'application/json'},
  body: {
    authorizedNetwork: '',
    createTime: '',
    domainResource: '',
    labels: {},
    name: '',
    state: '',
    statusMessage: '',
    updateTime: ''
  },
  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}}/v1alpha1/:parent/peerings');

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

req.type('json');
req.send({
  authorizedNetwork: '',
  createTime: '',
  domainResource: '',
  labels: {},
  name: '',
  state: '',
  statusMessage: '',
  updateTime: ''
});

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}}/v1alpha1/:parent/peerings',
  headers: {'content-type': 'application/json'},
  data: {
    authorizedNetwork: '',
    createTime: '',
    domainResource: '',
    labels: {},
    name: '',
    state: '',
    statusMessage: '',
    updateTime: ''
  }
};

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

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

const url = '{{baseUrl}}/v1alpha1/:parent/peerings';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"authorizedNetwork":"","createTime":"","domainResource":"","labels":{},"name":"","state":"","statusMessage":"","updateTime":""}'
};

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 = @{ @"authorizedNetwork": @"",
                              @"createTime": @"",
                              @"domainResource": @"",
                              @"labels": @{  },
                              @"name": @"",
                              @"state": @"",
                              @"statusMessage": @"",
                              @"updateTime": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1alpha1/:parent/peerings"]
                                                       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}}/v1alpha1/:parent/peerings" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"authorizedNetwork\": \"\",\n  \"createTime\": \"\",\n  \"domainResource\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"updateTime\": \"\"\n}" in

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

 "{{baseUrl}}/v1alpha1/:parent/peerings",
  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([
    'authorizedNetwork' => '',
    'createTime' => '',
    'domainResource' => '',
    'labels' => [
        
    ],
    'name' => '',
    'state' => '',
    'statusMessage' => '',
    'updateTime' => ''
  ]),
  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}}/v1alpha1/:parent/peerings', [
  'body' => '{
  "authorizedNetwork": "",
  "createTime": "",
  "domainResource": "",
  "labels": {},
  "name": "",
  "state": "",
  "statusMessage": "",
  "updateTime": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:parent/peerings');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'authorizedNetwork' => '',
  'createTime' => '',
  'domainResource' => '',
  'labels' => [
    
  ],
  'name' => '',
  'state' => '',
  'statusMessage' => '',
  'updateTime' => ''
]));

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

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

append(json_encode([
  'authorizedNetwork' => '',
  'createTime' => '',
  'domainResource' => '',
  'labels' => [
    
  ],
  'name' => '',
  'state' => '',
  'statusMessage' => '',
  'updateTime' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1alpha1/:parent/peerings');
$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}}/v1alpha1/:parent/peerings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "authorizedNetwork": "",
  "createTime": "",
  "domainResource": "",
  "labels": {},
  "name": "",
  "state": "",
  "statusMessage": "",
  "updateTime": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:parent/peerings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "authorizedNetwork": "",
  "createTime": "",
  "domainResource": "",
  "labels": {},
  "name": "",
  "state": "",
  "statusMessage": "",
  "updateTime": ""
}'

import http.client

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

payload = "{\n  \"authorizedNetwork\": \"\",\n  \"createTime\": \"\",\n  \"domainResource\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"updateTime\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v1alpha1/:parent/peerings", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:parent/peerings"

payload = {
    "authorizedNetwork": "",
    "createTime": "",
    "domainResource": "",
    "labels": {},
    "name": "",
    "state": "",
    "statusMessage": "",
    "updateTime": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:parent/peerings"

payload <- "{\n  \"authorizedNetwork\": \"\",\n  \"createTime\": \"\",\n  \"domainResource\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"updateTime\": \"\"\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}}/v1alpha1/:parent/peerings")

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  \"authorizedNetwork\": \"\",\n  \"createTime\": \"\",\n  \"domainResource\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"updateTime\": \"\"\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/v1alpha1/:parent/peerings') do |req|
  req.body = "{\n  \"authorizedNetwork\": \"\",\n  \"createTime\": \"\",\n  \"domainResource\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"updateTime\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1alpha1/:parent/peerings";

    let payload = json!({
        "authorizedNetwork": "",
        "createTime": "",
        "domainResource": "",
        "labels": json!({}),
        "name": "",
        "state": "",
        "statusMessage": "",
        "updateTime": ""
    });

    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 '{
  "authorizedNetwork": "",
  "createTime": "",
  "domainResource": "",
  "labels": {},
  "name": "",
  "state": "",
  "statusMessage": "",
  "updateTime": ""
}' |  \
  http POST {{baseUrl}}/v1alpha1/:parent/peerings \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "authorizedNetwork": "",\n  "createTime": "",\n  "domainResource": "",\n  "labels": {},\n  "name": "",\n  "state": "",\n  "statusMessage": "",\n  "updateTime": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1alpha1/:parent/peerings

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "authorizedNetwork": "",
  "createTime": "",
  "domainResource": "",
  "labels": [],
  "name": "",
  "state": "",
  "statusMessage": "",
  "updateTime": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1alpha1/:parent/peerings")! 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}}/v1alpha1/:name");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1alpha1/:name")

require "http/client"

url = "{{baseUrl}}/v1alpha1/:name"

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}}/v1alpha1/:name"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1alpha1/:name");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/:name"

	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/v1alpha1/:name HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/:name"))
    .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}}/v1alpha1/:name")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/v1alpha1/:name")
  .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}}/v1alpha1/:name');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/v1alpha1/:name'};

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

const url = '{{baseUrl}}/v1alpha1/:name';
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}}/v1alpha1/:name',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:name")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1alpha1/:name',
  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}}/v1alpha1/:name'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1alpha1/:name');

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

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

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

const options = {method: 'DELETE', url: '{{baseUrl}}/v1alpha1/:name'};

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

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

const url = '{{baseUrl}}/v1alpha1/:name';
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}}/v1alpha1/:name"]
                                                       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}}/v1alpha1/:name" in

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

 "{{baseUrl}}/v1alpha1/:name",
  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}}/v1alpha1/:name');

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:name');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v1alpha1/:name');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1alpha1/:name' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:name' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/v1alpha1/:name")

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:name"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:name"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1alpha1/:name")

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/v1alpha1/:name') do |req|
end

puts response.status
puts response.body

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

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

    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}}/v1alpha1/:name

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1alpha1/:name

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1alpha1/:name")! 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}}/v1alpha1/:name");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1alpha1/:name")

require "http/client"

url = "{{baseUrl}}/v1alpha1/:name"

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}}/v1alpha1/:name"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1alpha1/:name");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/:name"

	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/v1alpha1/:name HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1alpha1/:name")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/:name"))
    .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}}/v1alpha1/:name")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1alpha1/:name")
  .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}}/v1alpha1/:name');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1alpha1/:name'};

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

const url = '{{baseUrl}}/v1alpha1/:name';
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}}/v1alpha1/:name',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:name")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1alpha1/:name',
  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}}/v1alpha1/:name'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1alpha1/:name');

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

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

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

const options = {method: 'GET', url: '{{baseUrl}}/v1alpha1/:name'};

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

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

const url = '{{baseUrl}}/v1alpha1/:name';
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}}/v1alpha1/:name"]
                                                       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}}/v1alpha1/:name" in

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

 "{{baseUrl}}/v1alpha1/:name",
  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}}/v1alpha1/:name');

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:name');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1alpha1/:name');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1alpha1/:name' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:name' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1alpha1/:name")

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:name"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:name"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1alpha1/:name")

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/v1alpha1/:name') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v1alpha1/:name

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1alpha1/:name

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1alpha1/:name")! 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}}/v1alpha1/:resource:getIamPolicy");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1alpha1/:resource:getIamPolicy")

require "http/client"

url = "{{baseUrl}}/v1alpha1/:resource:getIamPolicy"

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}}/v1alpha1/:resource:getIamPolicy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1alpha1/:resource:getIamPolicy");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/:resource:getIamPolicy"

	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/v1alpha1/:resource:getIamPolicy HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1alpha1/:resource:getIamPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/:resource:getIamPolicy"))
    .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}}/v1alpha1/:resource:getIamPolicy")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1alpha1/:resource:getIamPolicy")
  .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}}/v1alpha1/:resource:getIamPolicy');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1alpha1/:resource:getIamPolicy'
};

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

const url = '{{baseUrl}}/v1alpha1/:resource:getIamPolicy';
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}}/v1alpha1/:resource:getIamPolicy',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:resource:getIamPolicy")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1alpha1/:resource:getIamPolicy',
  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}}/v1alpha1/:resource:getIamPolicy'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1alpha1/:resource:getIamPolicy');

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}}/v1alpha1/:resource:getIamPolicy'
};

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

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

const url = '{{baseUrl}}/v1alpha1/:resource:getIamPolicy';
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}}/v1alpha1/:resource:getIamPolicy"]
                                                       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}}/v1alpha1/:resource:getIamPolicy" in

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

 "{{baseUrl}}/v1alpha1/:resource:getIamPolicy",
  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}}/v1alpha1/:resource:getIamPolicy');

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:resource:getIamPolicy');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1alpha1/:resource:getIamPolicy');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1alpha1/:resource:getIamPolicy' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:resource:getIamPolicy' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1alpha1/:resource:getIamPolicy")

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:resource:getIamPolicy"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:resource:getIamPolicy"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1alpha1/:resource:getIamPolicy")

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/v1alpha1/:resource:getIamPolicy') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1alpha1/:resource:getIamPolicy";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v1alpha1/:resource:getIamPolicy

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1alpha1/:resource:getIamPolicy

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1alpha1/:resource:getIamPolicy")! 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}}/v1alpha1/:parent/peerings");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1alpha1/:parent/peerings")

require "http/client"

url = "{{baseUrl}}/v1alpha1/:parent/peerings"

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}}/v1alpha1/:parent/peerings"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1alpha1/:parent/peerings");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/:parent/peerings"

	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/v1alpha1/:parent/peerings HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1alpha1/:parent/peerings")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/:parent/peerings"))
    .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}}/v1alpha1/:parent/peerings")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1alpha1/:parent/peerings")
  .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}}/v1alpha1/:parent/peerings');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1alpha1/:parent/peerings'};

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

const url = '{{baseUrl}}/v1alpha1/:parent/peerings';
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}}/v1alpha1/:parent/peerings',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:parent/peerings")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1alpha1/:parent/peerings',
  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}}/v1alpha1/:parent/peerings'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1alpha1/:parent/peerings');

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}}/v1alpha1/:parent/peerings'};

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

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

const url = '{{baseUrl}}/v1alpha1/:parent/peerings';
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}}/v1alpha1/:parent/peerings"]
                                                       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}}/v1alpha1/:parent/peerings" in

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

 "{{baseUrl}}/v1alpha1/:parent/peerings",
  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}}/v1alpha1/:parent/peerings');

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:parent/peerings');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1alpha1/:parent/peerings');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1alpha1/:parent/peerings' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:parent/peerings' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1alpha1/:parent/peerings")

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:parent/peerings"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:parent/peerings"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1alpha1/:parent/peerings")

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/v1alpha1/:parent/peerings') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1alpha1/:parent/peerings";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v1alpha1/:parent/peerings

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1alpha1/:parent/peerings

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1alpha1/:parent/peerings")! 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, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1alpha1/:name");

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  \"authorizedNetwork\": \"\",\n  \"createTime\": \"\",\n  \"domainResource\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"updateTime\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/v1alpha1/:name" {:content-type :json
                                                            :form-params {:authorizedNetwork ""
                                                                          :createTime ""
                                                                          :domainResource ""
                                                                          :labels {}
                                                                          :name ""
                                                                          :state ""
                                                                          :statusMessage ""
                                                                          :updateTime ""}})

require "http/client"

url = "{{baseUrl}}/v1alpha1/:name"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"authorizedNetwork\": \"\",\n  \"createTime\": \"\",\n  \"domainResource\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"updateTime\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/v1alpha1/:name"),
    Content = new StringContent("{\n  \"authorizedNetwork\": \"\",\n  \"createTime\": \"\",\n  \"domainResource\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"updateTime\": \"\"\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}}/v1alpha1/:name");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"authorizedNetwork\": \"\",\n  \"createTime\": \"\",\n  \"domainResource\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"updateTime\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/:name"

	payload := strings.NewReader("{\n  \"authorizedNetwork\": \"\",\n  \"createTime\": \"\",\n  \"domainResource\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"updateTime\": \"\"\n}")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/v1alpha1/:name HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 161

{
  "authorizedNetwork": "",
  "createTime": "",
  "domainResource": "",
  "labels": {},
  "name": "",
  "state": "",
  "statusMessage": "",
  "updateTime": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/v1alpha1/:name")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"authorizedNetwork\": \"\",\n  \"createTime\": \"\",\n  \"domainResource\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"updateTime\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/:name"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"authorizedNetwork\": \"\",\n  \"createTime\": \"\",\n  \"domainResource\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"updateTime\": \"\"\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  \"authorizedNetwork\": \"\",\n  \"createTime\": \"\",\n  \"domainResource\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"updateTime\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:name")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/v1alpha1/:name")
  .header("content-type", "application/json")
  .body("{\n  \"authorizedNetwork\": \"\",\n  \"createTime\": \"\",\n  \"domainResource\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"updateTime\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  authorizedNetwork: '',
  createTime: '',
  domainResource: '',
  labels: {},
  name: '',
  state: '',
  statusMessage: '',
  updateTime: ''
});

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

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

xhr.open('PATCH', '{{baseUrl}}/v1alpha1/:name');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v1alpha1/:name',
  headers: {'content-type': 'application/json'},
  data: {
    authorizedNetwork: '',
    createTime: '',
    domainResource: '',
    labels: {},
    name: '',
    state: '',
    statusMessage: '',
    updateTime: ''
  }
};

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

const url = '{{baseUrl}}/v1alpha1/:name';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"authorizedNetwork":"","createTime":"","domainResource":"","labels":{},"name":"","state":"","statusMessage":"","updateTime":""}'
};

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}}/v1alpha1/:name',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "authorizedNetwork": "",\n  "createTime": "",\n  "domainResource": "",\n  "labels": {},\n  "name": "",\n  "state": "",\n  "statusMessage": "",\n  "updateTime": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"authorizedNetwork\": \"\",\n  \"createTime\": \"\",\n  \"domainResource\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"updateTime\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:name")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1alpha1/:name',
  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({
  authorizedNetwork: '',
  createTime: '',
  domainResource: '',
  labels: {},
  name: '',
  state: '',
  statusMessage: '',
  updateTime: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v1alpha1/:name',
  headers: {'content-type': 'application/json'},
  body: {
    authorizedNetwork: '',
    createTime: '',
    domainResource: '',
    labels: {},
    name: '',
    state: '',
    statusMessage: '',
    updateTime: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/v1alpha1/:name');

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

req.type('json');
req.send({
  authorizedNetwork: '',
  createTime: '',
  domainResource: '',
  labels: {},
  name: '',
  state: '',
  statusMessage: '',
  updateTime: ''
});

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

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

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

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v1alpha1/:name',
  headers: {'content-type': 'application/json'},
  data: {
    authorizedNetwork: '',
    createTime: '',
    domainResource: '',
    labels: {},
    name: '',
    state: '',
    statusMessage: '',
    updateTime: ''
  }
};

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

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

const url = '{{baseUrl}}/v1alpha1/:name';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"authorizedNetwork":"","createTime":"","domainResource":"","labels":{},"name":"","state":"","statusMessage":"","updateTime":""}'
};

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 = @{ @"authorizedNetwork": @"",
                              @"createTime": @"",
                              @"domainResource": @"",
                              @"labels": @{  },
                              @"name": @"",
                              @"state": @"",
                              @"statusMessage": @"",
                              @"updateTime": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1alpha1/:name"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/v1alpha1/:name" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"authorizedNetwork\": \"\",\n  \"createTime\": \"\",\n  \"domainResource\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"updateTime\": \"\"\n}" in

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

 "{{baseUrl}}/v1alpha1/:name",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'authorizedNetwork' => '',
    'createTime' => '',
    'domainResource' => '',
    'labels' => [
        
    ],
    'name' => '',
    'state' => '',
    'statusMessage' => '',
    'updateTime' => ''
  ]),
  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('PATCH', '{{baseUrl}}/v1alpha1/:name', [
  'body' => '{
  "authorizedNetwork": "",
  "createTime": "",
  "domainResource": "",
  "labels": {},
  "name": "",
  "state": "",
  "statusMessage": "",
  "updateTime": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:name');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'authorizedNetwork' => '',
  'createTime' => '',
  'domainResource' => '',
  'labels' => [
    
  ],
  'name' => '',
  'state' => '',
  'statusMessage' => '',
  'updateTime' => ''
]));

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

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

append(json_encode([
  'authorizedNetwork' => '',
  'createTime' => '',
  'domainResource' => '',
  'labels' => [
    
  ],
  'name' => '',
  'state' => '',
  'statusMessage' => '',
  'updateTime' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1alpha1/:name');
$request->setRequestMethod('PATCH');
$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}}/v1alpha1/:name' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "authorizedNetwork": "",
  "createTime": "",
  "domainResource": "",
  "labels": {},
  "name": "",
  "state": "",
  "statusMessage": "",
  "updateTime": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:name' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "authorizedNetwork": "",
  "createTime": "",
  "domainResource": "",
  "labels": {},
  "name": "",
  "state": "",
  "statusMessage": "",
  "updateTime": ""
}'

import http.client

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

payload = "{\n  \"authorizedNetwork\": \"\",\n  \"createTime\": \"\",\n  \"domainResource\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"updateTime\": \"\"\n}"

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

conn.request("PATCH", "/baseUrl/v1alpha1/:name", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:name"

payload = {
    "authorizedNetwork": "",
    "createTime": "",
    "domainResource": "",
    "labels": {},
    "name": "",
    "state": "",
    "statusMessage": "",
    "updateTime": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:name"

payload <- "{\n  \"authorizedNetwork\": \"\",\n  \"createTime\": \"\",\n  \"domainResource\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"updateTime\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1alpha1/:name")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"authorizedNetwork\": \"\",\n  \"createTime\": \"\",\n  \"domainResource\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"updateTime\": \"\"\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.patch('/baseUrl/v1alpha1/:name') do |req|
  req.body = "{\n  \"authorizedNetwork\": \"\",\n  \"createTime\": \"\",\n  \"domainResource\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"state\": \"\",\n  \"statusMessage\": \"\",\n  \"updateTime\": \"\"\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}}/v1alpha1/:name";

    let payload = json!({
        "authorizedNetwork": "",
        "createTime": "",
        "domainResource": "",
        "labels": json!({}),
        "name": "",
        "state": "",
        "statusMessage": "",
        "updateTime": ""
    });

    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("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

echo '{
  "authorizedNetwork": "",
  "createTime": "",
  "domainResource": "",
  "labels": {},
  "name": "",
  "state": "",
  "statusMessage": "",
  "updateTime": ""
}' |  \
  http PATCH {{baseUrl}}/v1alpha1/:name \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "authorizedNetwork": "",\n  "createTime": "",\n  "domainResource": "",\n  "labels": {},\n  "name": "",\n  "state": "",\n  "statusMessage": "",\n  "updateTime": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1alpha1/:name

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "authorizedNetwork": "",
  "createTime": "",
  "domainResource": "",
  "labels": [],
  "name": "",
  "state": "",
  "statusMessage": "",
  "updateTime": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1alpha1/:name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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}}/v1alpha1/:resource:setIamPolicy");

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  \"policy\": {\n    \"bindings\": [\n      {\n        \"condition\": {\n          \"description\": \"\",\n          \"expression\": \"\",\n          \"location\": \"\",\n          \"title\": \"\"\n        },\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\",\n    \"version\": 0\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1alpha1/:resource:setIamPolicy" {:content-type :json
                                                                            :form-params {:policy {:bindings [{:condition {:description ""
                                                                                                                           :expression ""
                                                                                                                           :location ""
                                                                                                                           :title ""}
                                                                                                               :members []
                                                                                                               :role ""}]
                                                                                                   :etag ""
                                                                                                   :version 0}}})

require "http/client"

url = "{{baseUrl}}/v1alpha1/:resource:setIamPolicy"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"policy\": {\n    \"bindings\": [\n      {\n        \"condition\": {\n          \"description\": \"\",\n          \"expression\": \"\",\n          \"location\": \"\",\n          \"title\": \"\"\n        },\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\",\n    \"version\": 0\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}}/v1alpha1/:resource:setIamPolicy"),
    Content = new StringContent("{\n  \"policy\": {\n    \"bindings\": [\n      {\n        \"condition\": {\n          \"description\": \"\",\n          \"expression\": \"\",\n          \"location\": \"\",\n          \"title\": \"\"\n        },\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\",\n    \"version\": 0\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}}/v1alpha1/:resource:setIamPolicy");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"policy\": {\n    \"bindings\": [\n      {\n        \"condition\": {\n          \"description\": \"\",\n          \"expression\": \"\",\n          \"location\": \"\",\n          \"title\": \"\"\n        },\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\",\n    \"version\": 0\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/:resource:setIamPolicy"

	payload := strings.NewReader("{\n  \"policy\": {\n    \"bindings\": [\n      {\n        \"condition\": {\n          \"description\": \"\",\n          \"expression\": \"\",\n          \"location\": \"\",\n          \"title\": \"\"\n        },\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\",\n    \"version\": 0\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/v1alpha1/:resource:setIamPolicy HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 276

{
  "policy": {
    "bindings": [
      {
        "condition": {
          "description": "",
          "expression": "",
          "location": "",
          "title": ""
        },
        "members": [],
        "role": ""
      }
    ],
    "etag": "",
    "version": 0
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1alpha1/:resource:setIamPolicy")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"policy\": {\n    \"bindings\": [\n      {\n        \"condition\": {\n          \"description\": \"\",\n          \"expression\": \"\",\n          \"location\": \"\",\n          \"title\": \"\"\n        },\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\",\n    \"version\": 0\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/:resource:setIamPolicy"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"policy\": {\n    \"bindings\": [\n      {\n        \"condition\": {\n          \"description\": \"\",\n          \"expression\": \"\",\n          \"location\": \"\",\n          \"title\": \"\"\n        },\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\",\n    \"version\": 0\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  \"policy\": {\n    \"bindings\": [\n      {\n        \"condition\": {\n          \"description\": \"\",\n          \"expression\": \"\",\n          \"location\": \"\",\n          \"title\": \"\"\n        },\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\",\n    \"version\": 0\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:resource:setIamPolicy")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1alpha1/:resource:setIamPolicy")
  .header("content-type", "application/json")
  .body("{\n  \"policy\": {\n    \"bindings\": [\n      {\n        \"condition\": {\n          \"description\": \"\",\n          \"expression\": \"\",\n          \"location\": \"\",\n          \"title\": \"\"\n        },\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\",\n    \"version\": 0\n  }\n}")
  .asString();

const data = JSON.stringify({
  policy: {
    bindings: [
      {
        condition: {
          description: '',
          expression: '',
          location: '',
          title: ''
        },
        members: [],
        role: ''
      }
    ],
    etag: '',
    version: 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}}/v1alpha1/:resource:setIamPolicy');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:resource:setIamPolicy',
  headers: {'content-type': 'application/json'},
  data: {
    policy: {
      bindings: [
        {
          condition: {description: '', expression: '', location: '', title: ''},
          members: [],
          role: ''
        }
      ],
      etag: '',
      version: 0
    }
  }
};

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

const url = '{{baseUrl}}/v1alpha1/:resource:setIamPolicy';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"policy":{"bindings":[{"condition":{"description":"","expression":"","location":"","title":""},"members":[],"role":""}],"etag":"","version":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}}/v1alpha1/:resource:setIamPolicy',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "policy": {\n    "bindings": [\n      {\n        "condition": {\n          "description": "",\n          "expression": "",\n          "location": "",\n          "title": ""\n        },\n        "members": [],\n        "role": ""\n      }\n    ],\n    "etag": "",\n    "version": 0\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  \"policy\": {\n    \"bindings\": [\n      {\n        \"condition\": {\n          \"description\": \"\",\n          \"expression\": \"\",\n          \"location\": \"\",\n          \"title\": \"\"\n        },\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\",\n    \"version\": 0\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:resource:setIamPolicy")
  .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/v1alpha1/:resource:setIamPolicy',
  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({
  policy: {
    bindings: [
      {
        condition: {description: '', expression: '', location: '', title: ''},
        members: [],
        role: ''
      }
    ],
    etag: '',
    version: 0
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:resource:setIamPolicy',
  headers: {'content-type': 'application/json'},
  body: {
    policy: {
      bindings: [
        {
          condition: {description: '', expression: '', location: '', title: ''},
          members: [],
          role: ''
        }
      ],
      etag: '',
      version: 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}}/v1alpha1/:resource:setIamPolicy');

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

req.type('json');
req.send({
  policy: {
    bindings: [
      {
        condition: {
          description: '',
          expression: '',
          location: '',
          title: ''
        },
        members: [],
        role: ''
      }
    ],
    etag: '',
    version: 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}}/v1alpha1/:resource:setIamPolicy',
  headers: {'content-type': 'application/json'},
  data: {
    policy: {
      bindings: [
        {
          condition: {description: '', expression: '', location: '', title: ''},
          members: [],
          role: ''
        }
      ],
      etag: '',
      version: 0
    }
  }
};

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

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

const url = '{{baseUrl}}/v1alpha1/:resource:setIamPolicy';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"policy":{"bindings":[{"condition":{"description":"","expression":"","location":"","title":""},"members":[],"role":""}],"etag":"","version":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 = @{ @"policy": @{ @"bindings": @[ @{ @"condition": @{ @"description": @"", @"expression": @"", @"location": @"", @"title": @"" }, @"members": @[  ], @"role": @"" } ], @"etag": @"", @"version": @0 } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1alpha1/:resource:setIamPolicy"]
                                                       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}}/v1alpha1/:resource:setIamPolicy" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"policy\": {\n    \"bindings\": [\n      {\n        \"condition\": {\n          \"description\": \"\",\n          \"expression\": \"\",\n          \"location\": \"\",\n          \"title\": \"\"\n        },\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\",\n    \"version\": 0\n  }\n}" in

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

 "{{baseUrl}}/v1alpha1/:resource:setIamPolicy",
  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([
    'policy' => [
        'bindings' => [
                [
                                'condition' => [
                                                                'description' => '',
                                                                'expression' => '',
                                                                'location' => '',
                                                                'title' => ''
                                ],
                                'members' => [
                                                                
                                ],
                                'role' => ''
                ]
        ],
        'etag' => '',
        'version' => 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}}/v1alpha1/:resource:setIamPolicy', [
  'body' => '{
  "policy": {
    "bindings": [
      {
        "condition": {
          "description": "",
          "expression": "",
          "location": "",
          "title": ""
        },
        "members": [],
        "role": ""
      }
    ],
    "etag": "",
    "version": 0
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:resource:setIamPolicy');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'policy' => [
    'bindings' => [
        [
                'condition' => [
                                'description' => '',
                                'expression' => '',
                                'location' => '',
                                'title' => ''
                ],
                'members' => [
                                
                ],
                'role' => ''
        ]
    ],
    'etag' => '',
    'version' => 0
  ]
]));

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

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

append(json_encode([
  'policy' => [
    'bindings' => [
        [
                'condition' => [
                                'description' => '',
                                'expression' => '',
                                'location' => '',
                                'title' => ''
                ],
                'members' => [
                                
                ],
                'role' => ''
        ]
    ],
    'etag' => '',
    'version' => 0
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1alpha1/:resource:setIamPolicy');
$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}}/v1alpha1/:resource:setIamPolicy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "policy": {
    "bindings": [
      {
        "condition": {
          "description": "",
          "expression": "",
          "location": "",
          "title": ""
        },
        "members": [],
        "role": ""
      }
    ],
    "etag": "",
    "version": 0
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:resource:setIamPolicy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "policy": {
    "bindings": [
      {
        "condition": {
          "description": "",
          "expression": "",
          "location": "",
          "title": ""
        },
        "members": [],
        "role": ""
      }
    ],
    "etag": "",
    "version": 0
  }
}'

import http.client

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

payload = "{\n  \"policy\": {\n    \"bindings\": [\n      {\n        \"condition\": {\n          \"description\": \"\",\n          \"expression\": \"\",\n          \"location\": \"\",\n          \"title\": \"\"\n        },\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\",\n    \"version\": 0\n  }\n}"

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

conn.request("POST", "/baseUrl/v1alpha1/:resource:setIamPolicy", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:resource:setIamPolicy"

payload = { "policy": {
        "bindings": [
            {
                "condition": {
                    "description": "",
                    "expression": "",
                    "location": "",
                    "title": ""
                },
                "members": [],
                "role": ""
            }
        ],
        "etag": "",
        "version": 0
    } }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:resource:setIamPolicy"

payload <- "{\n  \"policy\": {\n    \"bindings\": [\n      {\n        \"condition\": {\n          \"description\": \"\",\n          \"expression\": \"\",\n          \"location\": \"\",\n          \"title\": \"\"\n        },\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\",\n    \"version\": 0\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}}/v1alpha1/:resource:setIamPolicy")

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  \"policy\": {\n    \"bindings\": [\n      {\n        \"condition\": {\n          \"description\": \"\",\n          \"expression\": \"\",\n          \"location\": \"\",\n          \"title\": \"\"\n        },\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\",\n    \"version\": 0\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/v1alpha1/:resource:setIamPolicy') do |req|
  req.body = "{\n  \"policy\": {\n    \"bindings\": [\n      {\n        \"condition\": {\n          \"description\": \"\",\n          \"expression\": \"\",\n          \"location\": \"\",\n          \"title\": \"\"\n        },\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\",\n    \"version\": 0\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1alpha1/:resource:setIamPolicy";

    let payload = json!({"policy": json!({
            "bindings": (
                json!({
                    "condition": json!({
                        "description": "",
                        "expression": "",
                        "location": "",
                        "title": ""
                    }),
                    "members": (),
                    "role": ""
                })
            ),
            "etag": "",
            "version": 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 '{
  "policy": {
    "bindings": [
      {
        "condition": {
          "description": "",
          "expression": "",
          "location": "",
          "title": ""
        },
        "members": [],
        "role": ""
      }
    ],
    "etag": "",
    "version": 0
  }
}' |  \
  http POST {{baseUrl}}/v1alpha1/:resource:setIamPolicy \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "policy": {\n    "bindings": [\n      {\n        "condition": {\n          "description": "",\n          "expression": "",\n          "location": "",\n          "title": ""\n        },\n        "members": [],\n        "role": ""\n      }\n    ],\n    "etag": "",\n    "version": 0\n  }\n}' \
  --output-document \
  - {{baseUrl}}/v1alpha1/:resource:setIamPolicy

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["policy": [
    "bindings": [
      [
        "condition": [
          "description": "",
          "expression": "",
          "location": "",
          "title": ""
        ],
        "members": [],
        "role": ""
      ]
    ],
    "etag": "",
    "version": 0
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1alpha1/:resource:setIamPolicy")! 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}}/v1alpha1/:resource:testIamPermissions");

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  \"permissions\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1alpha1/:resource:testIamPermissions" {:content-type :json
                                                                                  :form-params {:permissions []}})

require "http/client"

url = "{{baseUrl}}/v1alpha1/:resource:testIamPermissions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"permissions\": []\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}}/v1alpha1/:resource:testIamPermissions"),
    Content = new StringContent("{\n  \"permissions\": []\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}}/v1alpha1/:resource:testIamPermissions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"permissions\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/:resource:testIamPermissions"

	payload := strings.NewReader("{\n  \"permissions\": []\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/v1alpha1/:resource:testIamPermissions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 23

{
  "permissions": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1alpha1/:resource:testIamPermissions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"permissions\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/:resource:testIamPermissions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"permissions\": []\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  \"permissions\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:resource:testIamPermissions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1alpha1/:resource:testIamPermissions")
  .header("content-type", "application/json")
  .body("{\n  \"permissions\": []\n}")
  .asString();

const data = JSON.stringify({
  permissions: []
});

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

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

xhr.open('POST', '{{baseUrl}}/v1alpha1/:resource:testIamPermissions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:resource:testIamPermissions',
  headers: {'content-type': 'application/json'},
  data: {permissions: []}
};

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

const url = '{{baseUrl}}/v1alpha1/:resource:testIamPermissions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"permissions":[]}'
};

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}}/v1alpha1/:resource:testIamPermissions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "permissions": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"permissions\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:resource:testIamPermissions")
  .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/v1alpha1/:resource:testIamPermissions',
  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({permissions: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:resource:testIamPermissions',
  headers: {'content-type': 'application/json'},
  body: {permissions: []},
  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}}/v1alpha1/:resource:testIamPermissions');

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

req.type('json');
req.send({
  permissions: []
});

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}}/v1alpha1/:resource:testIamPermissions',
  headers: {'content-type': 'application/json'},
  data: {permissions: []}
};

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

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

const url = '{{baseUrl}}/v1alpha1/:resource:testIamPermissions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"permissions":[]}'
};

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 = @{ @"permissions": @[  ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1alpha1/:resource:testIamPermissions"]
                                                       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}}/v1alpha1/:resource:testIamPermissions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"permissions\": []\n}" in

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

 "{{baseUrl}}/v1alpha1/:resource:testIamPermissions",
  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([
    'permissions' => [
        
    ]
  ]),
  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}}/v1alpha1/:resource:testIamPermissions', [
  'body' => '{
  "permissions": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:resource:testIamPermissions');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'permissions' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1alpha1/:resource:testIamPermissions');
$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}}/v1alpha1/:resource:testIamPermissions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "permissions": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:resource:testIamPermissions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "permissions": []
}'

import http.client

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

payload = "{\n  \"permissions\": []\n}"

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

conn.request("POST", "/baseUrl/v1alpha1/:resource:testIamPermissions", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:resource:testIamPermissions"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:resource:testIamPermissions"

payload <- "{\n  \"permissions\": []\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}}/v1alpha1/:resource:testIamPermissions")

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  \"permissions\": []\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/v1alpha1/:resource:testIamPermissions') do |req|
  req.body = "{\n  \"permissions\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1alpha1/:resource:testIamPermissions";

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

    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 '{
  "permissions": []
}' |  \
  http POST {{baseUrl}}/v1alpha1/:resource:testIamPermissions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "permissions": []\n}' \
  --output-document \
  - {{baseUrl}}/v1alpha1/:resource:testIamPermissions

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1alpha1/:resource:testIamPermissions")! 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}}/v1alpha1/:name/locations");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1alpha1/:name/locations")

require "http/client"

url = "{{baseUrl}}/v1alpha1/:name/locations"

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}}/v1alpha1/:name/locations"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1alpha1/:name/locations");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/:name/locations"

	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/v1alpha1/:name/locations HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1alpha1/:name/locations")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/:name/locations"))
    .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}}/v1alpha1/:name/locations")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1alpha1/:name/locations")
  .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}}/v1alpha1/:name/locations');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1alpha1/:name/locations'};

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

const url = '{{baseUrl}}/v1alpha1/:name/locations';
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}}/v1alpha1/:name/locations',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:name/locations")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1alpha1/:name/locations',
  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}}/v1alpha1/:name/locations'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1alpha1/:name/locations');

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}}/v1alpha1/:name/locations'};

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

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

const url = '{{baseUrl}}/v1alpha1/:name/locations';
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}}/v1alpha1/:name/locations"]
                                                       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}}/v1alpha1/:name/locations" in

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

 "{{baseUrl}}/v1alpha1/:name/locations",
  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}}/v1alpha1/:name/locations');

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:name/locations');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1alpha1/:name/locations');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1alpha1/:name/locations' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:name/locations' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1alpha1/:name/locations")

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:name/locations"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:name/locations"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1alpha1/:name/locations")

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/v1alpha1/:name/locations') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1alpha1/:name/locations";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v1alpha1/:name/locations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1alpha1/:name/locations

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1alpha1/:name/locations")! 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()